Collègien(ne), lycéen(ne) ou enseignant(e) en matière scientifique, jusqu'à ce lundi 31 janvier Casio t'a permis de participer à son formidable concours de Noël 2021.
Il te suffisait de programmer sur ta calculatrice Casio ou son émulateur ta liste au Père Noël, avec 3 catégories au choix :
catégorie étudiants : pour les participations individuelles d'élèves de collège ou lycée uniquement malgré le nom
catégorie professeurs : pour les participations individuelles des enseignant(e)s de matière scientifique en collège ou lycée
catégorie classes : pour les participations collectives de classes de collège ou lycée
Pour réaliser ton dessin, tu pouvais choisir entre les 2 technologies suivantes :
calculatrice scientifique fx-92+ Spéciale Collège avec son application Algorithmique t'offrant un langage de tracé à la Scratch/Logo
calculatrice graphique Graph 35+E II ou Graph 90+E avec son application Python
Pour chacune des 3 catégories étaient à gagner 2 superbes gros lots ; 1 pour le meilleur dessin sur fx-92+ Spéciale Collège, et 1 pour le meilleur dessin sur Graph 90/35+E II :
catégorie étudiants : console de jeux Nintendo Switch d'une valeur de 269,99€
catégorie professeurs : trottinette électrique d'une valeur de 199,99€
catégorie classes : 5 calculatrices graphiques au choix + montre Casio pour le professeur et chacun des élèves (calculatrice Graph 35+E II ou Graph 90+E + montre G-Shock ou vintage dans la limite de 35 élèves)
Et en prime avec Casio, pas de perdant : lot de goodiesCasio pour tous les autres participants !
Un superbe concours, merci Casio !
Le concours devait initialement se terminer le 7 janvier, mais la période de participation a été prolongée au dernier moment jusqu'au 31 janvier.
Aujourd'hui nous allons te présenter les créations conçues sur fx-92+ Spéciale Collège, et te révéler l'ensemble des gagnants.
Style Croix Aller à x=－10; y=10 Stylo écrit Aller à x=x＋19; y=y Aller à x=x＋1; y=y－1 Aller à x=x＋1; y=y Aller à x=x－1; y=y Aller à x=x＋2; y=y－2 Aller à x=x; y=y－5 Aller à x=x－6; y=y－12 Aller à x=x＋1; y=y－1 Aller à x=x; y=y－1 Aller à x=x－13; y=y Aller à x=x－2; y=y－2 Aller à x=x; y=y－2 Aller à x=x＋1; y=y－1 Aller à x=x＋4; y=y Aller à x=x; y=y＋3 Aller à x=x－1; y=y＋1 Stylo relevé Aller à x=x＋1; y=y－2 Stylo écrit Aller à x=x－3; y=y Aller à x=x; y=y－2 Stylo relevé Aller à x=x＋14; y=y＋5 Stylo écrit Aller à x=x＋3; y=y Aller à x=x＋2; y=y－2 Aller à x=x; y=y－3 Aller à x=x－2; y=y－2 Aller à x=x－21; y=y Aller à x=x－2; y=y＋2 Aller à x=x; y=y＋4 Aller à x=x＋8; y=y＋15 Aller à x=x; y=y＋6 Aller à x=x－6; y=y Aller à x=x＋3; y=y Aller à x=x; y=y－4 Aller à x=x－2; y=y－2 Aller à x=x＋4; y=y Aller à x=x－6; y=y Aller à x=x－2; y=y＋2 Aller à x=x; y=y＋4 Aller à x=x＋2; y=y＋2 Stylo relevé Aller à x=x＋9; y=y－3 y→B Répéter 9 Stylo écrit RanInt#(0;1)＋B→A Aller à x=x＋1; y=A ⤴ Stylo relevé Aller à x=x－9; y=y－5 y→B Répéter 10 Stylo écrit RanInt#(0;1)＋B→A Aller à x=x＋1; y=A ⤴ Stylo relevé Aller à x=x－11; y=y－4 y→B Répéter 12 Stylo écrit Aller à x=x＋1; y=A RanInt#(0;1)＋B→A ⤴ Stylo relevé Répéter 2 Aller à x=x－14; y=y－4 y→B Répéter 12 Stylo écrit RanInt#(0;1)＋B→A Aller à x=x＋1; y=A ⤴ Stylo relevé ⤴ Aller à x=50; y=20 Répéter 10 Aller à x=RanInt#(－90;90); y=RanInt#(－20;20) Stylo écrit Répéter 8 Avancer de 5 pixels Avancer de －5 pixels Tourner de ↺ 45 degrés ⤴ Stylo relevé ⤴
Aller à x=41; y=12 Stylo écrit Aller à x=45; y=14 Aller à x=60; y=5 Aller à x=60; y=12 Aller à x=47; y=18 Aller à x=41; y=18 Aller à x=38; y=13 Aller à x=45; y=22 Aller à x=61; y=22 Aller à x=67; y=18 Aller à x=71; y=2 Aller à x=67; y=－8 Répéter 8 Avancer de 4 pixels Tourner de ↺ －45 degrés ⤴ Aller à x=64; y=－10 Aller à x=60; y=－4 Aller à x=60; y=4 Aller à x=60; y=－4 Aller à x=55; y=－6 Aller à x=35; y=3 Aller à x=28; y=0 Aller à x=31; y=－16 Aller à x=38; y=－21 Aller à x=46; y=－21 Aller à x=55; y=－19 Aller à x=63; y=－14 Stylo relevé Aller à x=－1; y=20 Stylo écrit Répéter 2 Répéter 18 Avancer de 3 pixels Tourner de ↺ －20 degrés ⤴ Aller à x=17; y=18 ⤴ Aller à x=51; y=8 Aller à x=51; y=3 Aller à x=17; y=2 Stylo relevé Aller à x=－1; y=3 Stylo écrit Aller à x=11; y=4 Stylo relevé Aller à x=－4; y=15 Stylo écrit Aller à x=－2; y=13 Aller à x=－4; y=11 Aller à x=－6; y=13 Aller à x=－4; y=15 Stylo relevé Aller à x=14; y=13 Stylo écrit Aller à x=16; y=11 Aller à x=14; y=9 Aller à x=12; y=11 Aller à x=14; y=13 Stylo relevé Aller à x=42; y=－3 Stylo écrit Répéter 12 Avancer de 3 pixels Tourner de ↺ －30 degrés ⤴ Stylo relevé Aller à x=－60; y=0 Stylo écrit Aller à x=－70; y=－20 Aller à x=－90; y=－20 Aller à x=－70; y=20 Aller à x=－50; y=－20 Aller à x=－30; y=20 Aller à x=－10; y=20 Aller à x=－30; y=－20 Aller à x=－50; y=－20 Aller à x=－40; y=0 Aller à x=－50; y=20 Aller à x=－70; y=20 Stylo relevé －44→A －15→B 14→C 0→D Répéter 17 D＋1→D Aller à x=A; y=B Stylo écrit Aller à x=A＋C; y=B Stylo relevé A＋2→A B＋4→B SiB=21Alors －84→A －14→B Fin SiD≥14Alors C－4→C Fin ⤴ Stylo relevé Aller à x=－100; y=－30
Dans la catégorie élèves c'est _Orlando_ le grand gagnant qui pourra donc très bientôt se divertir sur une console Nintendo Switch.
Il place en effet la barre extrêmement haut :
il dessine pas moins de 7 images différentes, images ici non constituées de formes géométriques simples
et en prime il accompagne cela de quelques inscriptions
Or le langage ne fournit aucune instruction pour faire tout cela de façon simple, nous n'avons que les déplacements élémentaires du lutin/tortue, même pas de quoi écrire. Qui plus est la taille maximale du script est de 900 octets, franchement pas beaucoup pour stocker des images, de quoi afficher les images, et de quoi afficher des inscriptions.
En pratique _Orlando_ convertit les images monochromes qu'il souhaite afficher en nombres binaires (les bits 1 correspondant à des pixels à allumer et les bits 0 à des pixels à laisser éteints), et les inclut ensuite dans son script sous la forme de gros nombres décimaux.
Aux âmes bien nées la valeur n'attend point le nombre des années, c'est très hautement impressionnant. Une victoire largement méritée, nous sommes extrêmements fiers de lui, toutes nos félicitations !
Aller à x=-2; y=16 S'orienter à 180 degrés -10→E 54→M 73908999719→A 71030273809→B 7→C Répéter 9 39→D Si x=110 Alors Aller à x=-43; y=E 20→M 330302753020→A 5523528707→B 555001849→C Fin Si x=13 Alors Aller à x=-16; y=2E 189875800049→A 36479286949→B 4251023430→C Fin Si x=40 Alors Aller à x=11; y=E 219707870718→A 439093560256→B 2142255588→C Fin Si x=67 Alors Aller à x=38; y=2E 2097016270→A 138480215461→B 2261852748→C Fin Si x=94 Alors Aller à x=65; y=E 549629726467→A A－151674892→B 134415963→C Fin Si x=121 Alors Aller à x=94; y=2E 22→M 479650820087→A 139988187231→B 4262478351→C Fin Si x=150 Alors Aller à x=7E; y=2E 344638079224→A 274872652131→B 487935→C Fin x→F Répéter 117 Si D=0 Alors B→A C→B 39→D Fin D－1→D A÷2→A Si x<F－M＋2 Alors Aller à x=F; y=y＋2 Fin Avancer de ,6 pixels Si A≠Ent(A Alors Stylo écrit Ent(A→A Fin Aller à x=x; y=y＋1 Avancer de 1 pixels Aller à x=x－,4; y=y－1 Stylo relevé ⤴ Aller à x=F＋56; y=8(y－22 185247487863→A 335875282309→B 1→C ⤴
Afficher des cadeaux sur sa calculatrice c'est trop concret, _aubin_ nous met la chose en abyme. Il nous dessine en effet une console Nintendo Switch, et sur l'écran de cette dernière nous dessine une liste de cadeaux sélectionnés tout en finesse pour pour faire plaisir à Casio : calculatrice et dictionnaire électronique EX-Word de la marque entre autres.
Ici encore des images sans formes géométriques simples, et visiblement beaucoup plus détaillées que pour la participation précédente. Mais comment est-ce possible alors que cette dernière frôlait déjà la limite mémoire de 900 octets ?
Comme tu peux le voir ci-dessosu, le code est anormalement simple :
Aller à x=－96; y=23 Répéter 662 ? →A Répéter jusqu'à A=0 Si x=96 Alors Aller à x=－96; y=y－1 Fin Avancer de 1 pixels A－1→A ⤴ ? →A Répéter jusqu'à A=0 Stylo écrit Si x=96 Alors Stylo relevé Aller à x=－96; y=y－1 Stylo écrit Fin Avancer de ,4 pixels Stylo relevé Avancer de ,6 pixels A－1→A ⤴ ⤴ Stylo relevé Avancer de 193 pixels
C'est qu'_aubin_ s'est montré extrêmement malin pour contourner la limite de 900 octets, diabolique même, les données des images ne sont pas dans le script. Ce dernier demande en boucle à l'utilisateur de saisir les données (un fan de input(), cent20 devrait aimer) et c'est donc à l'utilisateur du script de saisir un par un les nombres de la liste communiquée avec la participation. _aubin_ a de plus mis en place une compression RLE afin de réduire la taille de cette dernière. Voici donc la liste en question à saisir :
Malgré la compression RLE cela fait quand même pas moins de 1324 nombres différents à saisir un par un en attendant à chaque fois la fin du déplacement du lutin/tortue.
Par contre il semble y avoir selon nos tests 2 erreurs faisant différer l'affichage de la photo d'_aubin_ partagée plus haut :
une ligne de données semble manquante, réduisant la hauteur des touches haut/bas du pavé directionnel inférieur gauche de la Switch, ainsi que celle de la rangée de touches correspondante sur la calculatrice
un peu après il semble de plus y avoir un décalage des données d'1 pixel horizontal
C'est extrêmement dommage, et nous sommes bien tristes de savoir que c'est peut-être ça qui l'a pénalisé lorsque nous pensons au nombre d'heures qu'_aubin_ a dû passer là-dessus.
Style Croix Aller à x=－80; y=－10 Stylo écrit Répéter 12 Avancer de 10 pixels Tourner de ↺ 180 degrés Avancer de 10 pixels Tourner de ↺ 15 degrés ⤴ Aller à x=－80; y=－20 S'orienter à 0 degrés Répéter 60 Avancer de 1,1 pixels Tourner de ↺ 6 degrés ⤴ Stylo relevé Aller à x=－40; y=－10 Stylo écrit Répéter 12 Avancer de 10 pixels Tourner de ↺ 180 degrés Avancer de 10 pixels Tourner de ↺ 15 degrés ⤴ Aller à x=－40; y=－20 S'orienter à 0 degrés Répéter 60 Avancer de 1,1 pixels Tourner de ↺ 6 degrés ⤴ Stylo relevé Aller à x=－64; y=－12 Stylo écrit Répéter 60 Avancer de 0,3 pixels Tourner de ↺ 6 degrés ⤴ Stylo relevé Aller à x=－40; y=－10 Stylo écrit Aller à x=－48; y=12 S'orienter à 0 degrés Avancer de 6 pixels Tourner de ↺ 90 degrés Avancer de 1 pixels Tourner de ↺ 90 degrés Avancer de 12 pixels Tourner de ↺ 90 degrés Avancer de 1 pixels Tourner de ↺ 90 degrés Avancer de 6 pixels Aller à x=－61,9; y=－9,8 Stylo relevé Aller à x=－80; y=－10 Stylo écrit Avancer de 12 pixels Stylo relevé Aller à x=－80; y=－10 S'orienter à 45 degrés Stylo écrit Avancer de 18 pixels Stylo relevé Aller à x=－68; y=－10 Avancer de 5 pixels S'orienter à 110 degrés Stylo écrit Avancer de 15 pixels S'orienter à 0 degrés Avancer de 4 pixels Tourner de ↺ 90 degrés Avancer de 1 pixels Tourner de ↺ 90 degrés Avancer de 8 pixels Tourner de ↺ 90 degrés Avancer de 1 pixels Tourner de ↺ 90 degrés Avancer de 4 pixels S'orienter à －70 degrés Avancer de 6 pixels S'orienter à 0 degrés Avancer de 14 pixels Stylo relevé Avancer de 200 pixels
Enfin, Zoé L. R. serait ravie d'accueillir un chat pour Noël.
Comme l'année dernière, le niveau sur fx-92+ Spéciale Collège reste très élevé ; c'est fantastique tout ce que l'on peut réaliser avec cette petite machine.
Merci Casio pour ce superbe concours fort généreusement doté qui a permis la création de tant de belles choses !
Collègien(ne), lycéen(ne) ou enseignant(e) en matière scientifique, jusqu'à ce lundi 31 janvier Casio t'a permis de participer à son formidable concours de Noël 2021.
Il te suffisait de programmer sur ta calculatrice Casio ou son émulateur ta liste au Père Noël, avec 3 catégories au choix :
catégorie étudiants : pour les participations individuelles d'élèves de collège ou lycée uniquement malgré le nom
catégorie professeurs : pour les participations individuelles des enseignant(e)s de matière scientifique en collège ou lycée
catégorie classe : pour les participations collectives de classes de collège ou lycée
Pour réaliser ton dessin, tu pouvais choisir entre les 2 technologies suivantes :
calculatrice scientifique fx-92+ Spéciale Collège avec son application Algorithmique t'offrant un langage de tracé à la Scratch/Logo
calculatrice graphique Graph 35+E II ou Graph 90+E avec son application Python
Pour chacune des 3 catégories étaient à gagner 2 superbes gros lots ; 1 pour le meilleur dessin sur fx-92+ Spéciale Collège, et 1 pour le meilleur dessin sur Graph 90/35+E II :
catégorie étudiants : console de jeux Nintendo Switch d'une valeur de 269,99€
catégorie professeurs : trottinette électrique d'une valeur de 199,99€
catégorie classe : 5 calculatrices graphiques au choix + montre Casio pour le professeur et chacun des élèves (calculatrice Graph 35+E II ou Graph 90+E + montre G-Shock ou vintage dans la limite de 35 élèves)
Et en prime avec Casio, pas de perdant : lot de goodiesCasio pour tous les autres participants !
Un superbe concours, merci Casio !
Le concours devait initialement se terminer le 7 janvier, mais la période de participation a été prolongée au dernier moment jusqu'au 31 janvier.
Nous avions très hâte de pouvoir te présenter les productions réalisées que nous espérions à la mesure de l'événement. Plusieurs candidats nous les ont fort aimablement partagées, découvrons tout cela ensemble.
J'ai envoyé une participation pour représenter TI-Planet le soir de la date butoir initiale, en précisant bien que c'était pour le plaisir. Je ne souhaite en effet piquer de gros lots à personne ; même si il s'agit de très grots lots, il n'y en a que 6.
J'ai donc l'honneur et le plaisir de vous partager ma participation finale comme promis, préparée avec soin un petit peu chaque jour à compter de début décembre. Le script fait 1453 lignes et 73,717 Ko ; le script Python le plus gros jamais sorti sur machines Casio ! (et ce n'est pas demain la veille qu'il tournera sur les modèles de milieu de gamme concurrents... )
Il s'agit non pas d'un simple dessin mais d'une véritable animation qui prend 15 minutes environ sur simulateur USB avant de boucler indéfiniment. Elle est à la gloire d'un future modèle haut de gamme, la Casio Classpad III fx-CP600 qui, je l'espère, aura une application Python avec une fonction get_key() dedans.
"Dessiner sa liste au Père Noël" je trouver cette consigne un petit peu trop terre à terre, trop concrète ; j'ai pensé faire l'original en y répondant de façon meta(ou mise en abyme si tu préfères) : sur l'écran de Graph 90+E je dessine donc une calculatrice fx-CP600, et sur l'écran dessiné de cette fx-CP600 je dessine les anciennes application Classpad ainsi que la nouvelle application Classpad Python. Si j'avais su, attends de voir les participations qui vont suivre...
L'animation commence par présenter la frise chronologique des modèles Casio Classpad couleur, avant de faire intervenir le Père Noël pour la livraison de la fx-CP600 :
Pour les affichages, j'ai codé une classe qui me sert de calque et permet ainsi :
d'afficher un objet à différents endroits de l'écran
d'afficher un objet sous forme zoomée/dézoomée
d'afficher des rotations à 90° d'un objet
d'animer des déplacements
d'animer des zooms
Concernant les diverses images utilisées pour les calculatrices et leurs écrans, elles ont été conçues avec un logiciel de retouche d'images avant d'être converties en code Python pour Graph 90+E à l'aide de l'outil de conversion en ligne img2calc.
Concernant les inscriptions sous forme de texte, comme la méthode officielle casioplot.draw_string() ne permet ni les rotations ni les zooms j'ai dû tout refaire, c'est-à-dire recoder intégralement en Python la police de caractères. Ce fut d'ailleurs l'occasion d'inclure différentes tailles de polices, afin d'avoir un meilleur affichage en fonction du niveau de zoom. Il s'agit toutes de polices présentes sur Graph 35+E II ou Graph 90+E, extraites à l'aide d'un script Python à coups de get_pixel() :
5 pixels de hauteur (police "small/medium" Graph 35+E II)
7 pixels de hauteur (police "large" Graph 35+E II)
10 pixels de hauteur (police "small" Graph 90+E)
Maintenant que les données de polices sont directement dans notre script, on peut effectivement les afficher comme on veut, selon différents niveaux de zoom ou différentes orientations. Ces polices ont au passage été étendues de quelques caractères spéciaux absents qui étaient nécessaires ici.
Voici enfin une capture animée de ma participation ; ne pas hésiter à la jouer en vitesse x2 :
def cos90(a): a %= 4 return a==0 and 1 or a==2 and -1
def sin90(a): a %= 4 return a==1 and 1 or a==3 and -1
def nullbits(n): k = 0 while n and not (n % 2): n //= 2 k += 1 return k
################# # font functions ################# def blank_char(font_h): return [0 for k in range(font_h)]
def complete_font(font_bm, n, val): while(len(font_bm) < n): font_bm.append(val)
def shift_char_left(char_bm): kbits = -1 for v in char_bm: if v: kv = nullbits(v) if kbits < 0: kbits = kv else: kbits = min(kbits, kv) if kbits >= 0: k = 2 ** kbits if k > 1: for i in range(len(char_bm)): char_bm[i] //= k
def shift_font_left(font_bm): for char_bm in font_bm: shift_char_left(char_bm)
def gen_font_widths(font_bm): font_h = len(font_bm[0]) for char_bm in font_bm: if len(char_bm) <= font_h: char_w = 0 for row in char_bm: row_w = 0 while row: row_w += 1 row //= 2 if not char_w: char_w = 2 * FONT_INTERSPACE char_w = max(char_w, row_w) char_bm.append(char_w + FONT_INTERSPACE)
############################# # font data + initialization ############################# # most chars come from the Graph 35+E II or Graph 90+E
def fill_rect(x, y, w, h, c): if w and h: for dy in range(0, h, sign(h)): for dx in range(0, w, sign(w)): set_pixel(x + dx, y + dy, c)
def fill_ellipse(x, y, rx, ry, c): ry = abs(ry) for h in range(-int(ry), int(ry)+1): w = sqrt(max(0, rx*rx*(1-h*h/ry/ry))) fill_rect(int(x - w), int(y + h), int(2 * w), 1, c)
def fill_circle(x, y, r, c): if r: for h in range(int(r)+1): w = round(sqrt(max(0, r*r*(1-h*h/r/r)))) fill_rect(x, y + h, w, 1, c) fill_rect(x, y + h, -w, 1, c) fill_rect(x, y - h, w, 1, c) fill_rect(x, y - h, -w, 1, c) # fill_rect(int(x - w), int(y + h), int(2 * w), 1, c) # fill_rect(int(x - w), int(y - h), int(2 * w), 1, c) # for h in range(-int(r), int(r)+1): # w = sqrt(max(0, r*r*(1-h*h/r/r))) # fill_rect(int(x - w), int(y + h), int(2 * w), 1, c)
def fill_rect_4_circles(x, y, w, h, r, c): fill_rect(x + sign(w)*r, y, w - sign(w)*2*r, h, c) fill_rect(x, y + sign(h)*r, w, h - sign(h)*2*r, c) fill_circle(x + sign(w)*r, y + sign(h)*r, r, c) fill_circle(x + w - sign(w) - sign(w)*r, y + sign(h)*r, r, c) fill_circle(x + sign(w)*r, y + h - sign(h) - sign(h)*r, r, c) fill_circle(x + w - sign(w) - sign(w)*r, y + h - sign(h) - sign(h)*r, r, c)
def fill_rect_2_circles_left(x, y, w, h, r, c, rot): if rot % 2: fill_rect(x, y + r*sign(h), w, h - r*sign(h), c) fill_rect(x + r*sign(w), y, w - 2*r*sign(w), h - r*sign(h), c) fill_circle(x + w - sign(w) - r*sign(w), y + r*sign(h), r, c) fill_circle(x + r*sign(w), y + r*sign(h), r, c) else: fill_rect(x + r*sign(w), y, w - r*sign(w), h, c) fill_rect(x, y + r*sign(h), w, h - 2*r*sign(h), c) fill_circle(x + r*sign(w), y + r*sign(h), r, c) fill_circle(x + r*sign(w), y + h - sign(h) - r, r, c)
def fill_rect_2_circles_right(x, y, w, h, r, c, rot): if rot % 2: fill_rect(x, y, w, h - r*sign(h), c) fill_rect(x + r*sign(w), y, w - 2*r*sign(w), h - r*sign(h), c) fill_circle(x + w - sign(w) - r*sign(w), y + h - sign(h) - r*sign(h), r, c) fill_circle(x + r*sign(w), y + h - sign(h) - r*sign(h), r, c) else: fill_rect(x, y, w - cos90(rot)*r*sign(w), h, c) fill_rect(x, y + cos90(rot)*r*sign(h), w, h - cos90(rot)*2*r*sign(h), c) fill_circle(x + w - sign(w) - cos90(rot)*r*sign(w), y + cos90(rot)*r*sign(h), r, c) fill_circle(x + w - sign(w) - cos90(rot)*r*sign(w), y + h - sign(h) - cos90(rot)*r*sign(h), r, c)
def fill_rect_2_ellipses(x, y, w, h, r, c, rot): if rot % 2: rx, ry = w / 2, r fill_rect(x, y + sin90(rot)*r, w, h - sin90(rot)*2*r, c) fill_ellipse(x + (w - sign(w))//2, y + sin90(rot)*ry, int(rx), ry, c) fill_ellipse(x + (w - sign(w))//2, y + h - sign(h) - sin90(rot)*ry, int(rx), ry, c) else: rx, ry = r, h / 2 fill_rect(x + cos90(rot)*r, y, w - cos90(rot)*2*r, h, c) fill_ellipse(x + cos90(rot)*rx, y + (h - sign(h))//2, rx, int(ry), c) fill_ellipse(x + w - sign(w) - cos90(rot)*rx, y + (h - sign(h))//2, rx, int(ry), c)
def draw_char(x, y, st, c, rot, zoom=1, i_font = 0, sh=1): font_h = font_h_l[i_font] font_bm = font_bm_l[i_font] if rot % 2 and sh < 0: x -= 2 * sin90(rot) * font_h if rot % 2 == 0 and sh < 0: y += 2 * cos90(rot) * font_h bm = font_bm[ord(st[0])] for iy in range(font_h): row = bm[iy] ix = 0 while row: if row & 1: if rot%2: fill_rect(x - iy*zoom*sin90(rot)*sign(sh), y + ix*sin90(rot), zoom, zoom, c) else: fill_rect(x + ix*cos90(rot), y + iy*zoom*cos90(rot)*sign(sh), zoom, zoom, c) row //= 2 ix += zoom
def string_width(st, i_font = 0): font_h = font_h_l[i_font] font_bm = font_bm_l[i_font] stw = -FONT_INTERSPACE for ch in st: if ch == "\n": break stw += font_bm[ord(ch)][font_h] if ch == "\n": stw = max(string_width(st[st.index("\n")+1:], i_font), stw) return stw
def string_height(st, i_font = 0): font_h = font_h_l[i_font] font_bm = font_bm_l[i_font] sth = font_h for ch in st: if ch == "\n": sth += font_h + 1 return sth
def draw_string_rotated(x, y, lst, c, rot, w=0, h=0, centerw=True, sh=1): i_font = 0 font_h = font_h_l[i_font] font_bm = font_bm_l[i_font] if isinstance(lst, str): lst = (lst,) lst = sorted(lst, key=string_width, reverse=True) stw = rot % 2 and h + 1 or w + 1
while (stw > w and rot%2 == 0 or stw>h and rot%2) and len(lst): st, lst = lst[0], lst[1:] stw = string_width(st, i_font)
k_font = len(font_h_l) stw = rot % 2 and h + 1 or w + 1 while (stw > w and rot%2 == 0 or stw>h and rot%2) and k_font: k_font -= 1 stw = string_width(st, k_font) i_font = k_font font_h = font_h_l[i_font] font_bm = font_bm_l[i_font] sth = string_height(st, i_font) if rot % 2: zoomf = max(1, min(h // stw, w // sth)) zoom = int(zoomf) if centerw: y += sin90(rot) * (h - stw*zoomf) // 2 x -= sin90(rot) * (w - sth*zoomf) // 2 else: zoomf = max(1, min(w // stw, h // sth)) zoom = int(zoomf) if centerw: x += cos90(rot) * (w - stw*zoomf) // 2 y += cos90(rot) * (h - sth*zoomf) // 2 x0, y0 = x, y for ch in st: if ch == "\n": if rot % 2: y = y0 - sin90(rot) x -= sin90(rot) * (font_h + FONT_INTERSPACE) * zoom * sign(sh) else: x = x0 - cos90(rot) y += cos90(rot) * (font_h + FONT_INTERSPACE) * zoom * sign(sh) draw_char(x, y, ch, c, rot, zoom, i_font, sh) bm = font_bm[ord(ch)] if rot % 2: y += sin90(rot) * bm[font_h] * zoom else: x += cos90(rot) * bm[font_h] * zoom
def image_height(rle, w, pal): i, x, y = 0, 0, 0 nvals = len(pal) nbits = 0 nvals -= 1 while(nvals): nvals >>= 1 nbits += 1 maskval = (1 << nbits) - 1 maskcnt = (0xFF >> nbits >> 1) << nbits while i<len(rle): v = rle[i] mv = v & maskval c = (v & maskcnt) >> nbits if (v & 0b10000000 or nbits == 8): i += 1 c |= rle[i] << (7 - nbits + (nbits == 8)) c = (c + 1) while c: cw = min(c, w - x) c -= cw x = (x + cw) % w y += x == 0 i += 1 return y
def draw_image_rotated(data_l, x0, y0, pal, wr, hr, rot, itransp): f = lambda l: l[0] data_l = sorted(data_l, key=f, reverse=True) w = rot % 2 and hr + 1 or wr + 1 while (w > wr and rot%2 == 0 or w > hr and rot%2) and len(data_l): data, data_l = data_l[0], data_l[1:] w = data[0] rle = data[1] i, x, y = 0, 0, 0 x0, y0 = int(x0), int(y0) h = image_height(rle, w, pal) zoom_kx = sign(wr) wr = abs(wr) if rot % 2: zoomf = max(1, min(hr // w, wr // h)) zoom = int(zoomf) y0 += sin90(rot) * (hr - w*zoomf) // 2 x0 -= sin90(rot) * (wr - h*zoomf) // 2 else: zoomf = max(1, min(wr // w, hr // h)) zoom = int(zoomf) x0 += cos90(rot) * (wr - w*zoomf) // 2 y0 += cos90(rot) * (hr - h*zoomf) // 2 nvals = len(pal) nbits = 0 nvals -= 1 while(nvals): nvals >>= 1 nbits += 1 maskval = (1 << nbits) - 1 maskcnt = (0xFF >> nbits >> 1) << nbits while i<len(rle): v = rle[i] mv = v & maskval c = (v & maskcnt) >> nbits if (v & 0b10000000 or nbits == 8): i += 1 c |= rle[i] << (7 - nbits + (nbits == 8)) c = (c + 1) while c: cw = min(c, w - x) if mv != itransp: if rot%2: fill_rect(x0, y0 + x*zoom*sin90(rot)*zoom_kx, zoom, cw*zoom*sin90(rot)*zoom_kx, pal[mv]) else: fill_rect(x0 + x*zoom*cos90(rot)*zoom_kx, y0, cw*zoom*cos90(rot)*zoom_kx, zoom, pal[mv]) c -= cw x = (x + cw) % w if rot%2: x0 -= (x == 0) and zoom * sin90(rot) else: y0 += x == 0 and zoom * cos90(rot) i += 1
def slide_cp(x, y, dx, dy, n, w, h, rot, mode, page, clean_over_func=None, clean_under_funcs=None): if callable(clean_under_funcs): clean_under_funcs = tuple(clean_under_funcs) elif not clean_under_funcs: clean_under_funcs = [] for k in range(ceil(n / max(abs(dx), abs(dy))) + 1): for f in clean_under_funcs: f() draw_cp(x, y, w, h, rot, mode, page) if clean_over_func: clean_over_func() show_screen() x += dx y += dy return x - dx, y - dy
def slide_img(x, y, dx, dy, n, img, img_w, img_h, img_pal, rot=0, itransp=-1, clean_over_func=None, clean_under_funcs=None): if callable(clean_under_funcs): clean_under_funcs = tuple(clean_under_funcs) elif not clean_under_funcs: clean_under_funcs = [] for k in range(n): for f in clean_under_funcs: f() draw_image_rotated(((img_w,img),), x, y, img_pal, img_w, img_h, rot, itransp) if clean_over_func: clean_over_func() show_screen() x += dx y += dy return x - dx, y - dy
def slide_imgs_forx(y, dy, n, img, img_w, img_h, img_pal, rot=0, itransp=-1, half = False, clean_over_func=None, clean_under_funcs=None): if callable(clean_under_funcs): clean_under_funcs = tuple(clean_under_funcs) elif not clean_under_funcs: clean_under_funcs = [] if half: half = 2 for k in range(n): for f in clean_under_funcs: f() for x in range(0, screen_w, img_w): draw_image_rotated(((img_w,img),), x + (half % 2 and img_w - 1), y, img_pal, img_w * (half % 2 and -1 or 1), img_h, rot, itransp) if half: half += 1 if clean_over_func: clean_over_func() show_screen() y += dy return y - dy
def fill_rect(self, x, y, w, h, c): x, y = self.rescale_xy(x, y) w, h = self.rescale_wh(w, h) fill_rect(x, y, w, h, c)
def fill_rect_4_circles(self, x, y, w, h, r, c): x, y = self.rescale_xy(x, y) w, h = self.rescale_wh(w, h) r = self.rescale_l(r) fill_rect_4_circles(x, y, w, h, r, c)
def fill_rect_2_circles_left(self, x, y, w, h, r, c): x, y = self.rescale_xy(x, y) w, h = self.rescale_wh(w, h) r = self.rescale_l(r) fill_rect_2_circles_left(x, y, w, h, r, c, self.rot)
def fill_rect_2_circles_right(self, x, y, w, h, r, c): x, y = self.rescale_xy(x, y) w, h = self.rescale_wh(w, h) r = self.rescale_l(r) fill_rect_2_circles_right(x, y, w, h, r, c, self.rot)
def fill_rect_2_ellipses(self, x, y, w, h, r, c): x, y = self.rescale_xy(x, y) w, h = self.rescale_wh(w, h) r = self.rescale_l(r) fill_rect_2_ellipses(x, y, w, h, r, c, self.rot)
def draw_string_rotated(self, x, y, st, c, w=0, h=0, centerw=True): sh = h x, y = self.rescale_xy(x, y) w, h = self.rescale_wh(w, h) w, h = abs(w), abs(h) draw_string_rotated(x, y, st, c, self.rot, w, h, centerw, sign(sh))
def draw_floor(): for x in range(0, screen_w, floor_img_w): draw_image_rotated(((floor_img_w, floor_img),), x, floor_img_y, floor_img_pal, floor_img_w, floor_img_h, 0, -1)
def draw_back(): for y in range(ceil(screen_h / 32)): for x in range(ceil(screen_w / 32)): draw_image_rotated(((back_img_w, back_img),), x * back_img_w, y * back_img_h, back_img_pal, back_img_w, back_img_h, 0, -1)
def draw_cps(anim = False): for i in range(len(cp_imgs)): if cp_imgs[i][1] < screen_h: draw_cp(cp_imgs[i][0], cp_imgs[i][1], cp_imgs[i][2], cp_imgs[i][3], 0, i, cp_imgs[i][5]) if anim: cp_imgs[i][5] = (cp_imgs[i][5] + 1) % N_PAGES
line = [] if mode == MODE_FXCP600: line.append(app_physium) line.append(app_algy2) apps.append(line)
for iy in range(len(apps)): for ix in range(min(2, len(apps[iy]))): x, y = x0 + ix*318, 210 + iy*156 w, h = len(apps[iy]) == 1 and page == PAGE_MENU_1 and 612 or 294, 114 canvas.fill_rect_4_circles(x, y, w, h, 10, (156, 153, 156)) canvas.fill_rect_4_circles(x + 8, y + 10, w - 16, h - 16, 7, (205, 210, 213)) canvas.fill_rect_4_circles(x + 16, y + 16, w - 32, h - 32, 4, (231, 235, 232)) canvas.fill_rect_2_circles_left(x, y, h, h, 8, apps[iy][ix][1]) canvas.draw_image_rotated(apps[iy][ix][2], x, y, (BLACK, WHITE), h, h, 0) canvas.draw_string_rotated(x + h, y, apps[iy][ix][0], BLACK, w - 122, h, False) return canvas.w, canvas.h
data = ( (2013, "Classpad II fx-CP400"), (2016, "Classpad II fx-CP400+E"), (2017, "fx-CG500"), (2022, "Classpad III fx-CP600"), ) w, h = draw_cp(screen_w, 0, screen_w, screen_h, 3, MODE_FXCP400) fullw = w + sled_img_w for x in range(screen_w, -len(data)*fullw, -2): clear_screen() for mode in range(len(data)): x0 = x + fullw*mode if x0 < screen_w and x0 + w + sled_img_halfw> 0: c = ((127,0,0),(127,0,127),(127,127,0),(0,0,127))[mode] if mode == MODE_FXCP600: draw_image_rotated(((sled_img_w, sled_img),), x0, 0, (BLACK, c), sled_img_w, screen_h, 0, 0) draw_string_rotated(x0 + sled_img_halfw, 0, "?", c, 0, w, h) else: draw_image_rotated(((sled_img_w, sled_img),), x0, 0, (BLACK, c), sled_img_w, screen_h, 0, 0) draw_cp(x0 + sled_img_halfw + screen_w, 0, screen_w, screen_h, 1, mode, [PAGE_OFF, PAGE_LOGOBAT_ON, PAGE_MENU_1][mode]) draw_string_rotated(x0, 0, str(data[mode][0]) + ":", c, 0, sled_img_halfw, screen_h - h) draw_string_rotated(x0, h, "Casio", c, 0, sled_img_halfw, screen_h - h) draw_string_rotated(x0 + sled_img_halfw, h, data[mode][1], c, 0, screen_w, screen_h - h) show_screen()
# credits : # 5 pixels character font : based on the Casio Graph 35+E II / fx-9750/9850GIII Python application tiny/medium font # 7 pixels character font : based on the Casio Graph 35+E II / fx-9750/9850GIII Python application large font # 10 pixels character font : based on the Casio Graph 90+E / fx-CG50 Python application tiny font # fx-CP400 skin : based on the one used in the Casio Classpad II Manager software # fx-CG500 skin : based on the one used in the Casio fx-CG500 Manager software # Classpad screens : based on Casio fx-CP400 screen captures or pictures # back + floor sprites : Toad house sprites from the "Super Mario All-Stars: Super Mario Bros 3" Nintendo SNES game # curtain + floor : based on the Toad house sprite from the "Super Mario All-Stars: Super Mario Bros 3" Nintendo SNES game # Christmas sled image : http://clipart-library.com/clipart/1133395.htm (personal use license) # Christmas tree image : http://clipart-library.com/clip-art/christmas-tree-silhouette-vector-13.htm (personal use license)
Lephe a également envoyé quelque chose pour représenter Planète Casio. Participation hors concours puisque n'étant plus lycéen, et pas (encore ?...) enseignant.
Afficher ses cadeaux sur une Graph 90+E, Lephe semble avoir pensé comme moi : c'est trop simple, trop concret, pas suffisamment 'meta' à son goût, il faut trouver un moyen de tordre la consigne, de se distinguer... Voici donc sur l'écran Graph 90+E le dessin d'une Graph 90+E, dont l'écran dessiné affiche à son tour les cadeaux !
Ici encore une animation mais quelle animation, la Graph 90+E étant en effet affichée en 3D. Il s'agit d'un moteur semi-complet avec rastérization de triangles (par Ninestars), textures, z-buffer, et effet d'assombrissement avec la profondeur.
L'affichage est certes petit mais c'est fait exprès ; cela permet à l'animation de se jouer sur calculatrice en un temps raisonnable, contrairement à la participation précédente qui cible le simulateur beaucoup plus rapide sur clé USB.
Les données brutes (RGB-888) d'une image 43×90 pixels fournie par le script img.py sont plaquées sur un pavé droit qui se met ensuite à tourner sous nos yeux émervéillés :
for x in range(min_x, max_x+1): u0 = u0_start u1 = u1_start u2 = u2_start z_num = z_num_start z_div = z_div_start
for y in range(min_y, max_y+1): if (u0 | u1 | u2) > 0 and zbuf[y*WIDTH+x] > z_num: if color is None: w = int(((u0 * w0 + u1 * w1 + u2 * w2) // z_div) % TEX_WIDTH) h = int(((u0 * h0 + u1 * h1 + u2 * h2) // z_div) % TEX_HEIGHT) row = TEXTURE_GRAPH90[h] c = (row[3*w], row[3*w+1], row[3*w+2]) else: c = color
# Put pixel r = c[0] * (32768-z_num) >> 15 g = c[1] * (32768-z_num) >> 15 b = c[2] * (32768-z_num) >> 15 set_pixel(x, y, (r, g, b)) zbuf[y*WIDTH+x] = z_num
ptitjoz n'ayant lui plus le privilège d'être élève et pas encore celui d'être enseignant, a malgré tout fait l'effort d'adresser pour le plaisir à Casio une participation hors concours en Python sur Graph 90+E.
Il en profite pour leur transmettre un mystérieux message, GETKEY(). Les vrais savent...
Visiblement, je ne suis pas le seul à m'être retapé tout l'alphabet pour ce concours. En effet Afyu, enseignant en Mathématiques, a quant à lui conçu sa liste de Noël en écriture manuscrite pour la bibliothèque turtle de la Graph 90+E, et ici encore la chose est animée.
D'autant plus impressionnant que la tortue écrit et enchaîne les lettres littéralement sans lever le stylo, exactement comme si elle écrivait à la main, regarde bien la construction de l'animation :
from turtle import * from random import * from math import sin,cos,pi
taille_initiale=1 l_liste=215 h_liste=150
def tracer(lettre,x,y): global taille_initiale #hideturtle() if lettre == "a": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(4) rt(130) for i in range(30): fd(1) lt(18) setheading(-90) fd(-3) fd(4) for i in range(4): lt(18) fd(1)
if lettre == "b": penup() goto(x,y) pendown() setheading(-10) for i in range(10): lt(20-2*i) fd(2) #lt(6-i) for i in range(5): lt(30) fd(1) for i in range(9): fd(2) lt(2*i+4) for i in range(4): lt(25) fd(1) rt(95) fd(2) if lettre == "c": penup() goto(x,y) setheading(30) # vers la droite pendown() fd(5) lt(75) for i in range(8): fd(1) rt(18) rt(162) for i in range(15): fd(1) lt(18) if lettre == "d": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(4) rt(130) for i in range(30): fd(1) lt(18) setheading(-90) fd(-10) fd(11) for i in range(4): lt(18) fd(1) if lettre == "e": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(5) rt(90) for i in range(10): fd(1) lt(15) lt(30) for i in range(10): lt(25) fd(2) if lettre == "E": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(5) rt(90) for i in range(10): fd(1) lt(15) lt(30) for i in range(10): lt(25) fd(2) penup() goto(x+5,y+12) pendown() setheading(45) fd(5) if lettre == "W": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(5) rt(90) for i in range(10): fd(1) lt(15) lt(30) for i in range(10): lt(25) fd(2) penup() goto(x+2,y+13) pendown() setheading(0) fd(2) penup() fd(2) pendown() fd(2) if lettre == "f": penup() goto(x,y) setheading(-10) pendown() fd(2) for i in range(9): lt(20-2*i) fd(2) for i in range(9): lt(19) fd(1) fd(22) for i in range(9): fd(1) lt(21) for i in range(6): fd(2) lt(2*i) rt(150) for i in range(3): fd(2) lt(20) if lettre == "g": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(4) rt(130) for i in range(30): fd(1) lt(18) setheading(-90) fd(-3) fd(14) for i in range(9): rt(19) fd(1) for i in range(6): rt(20-2*i) fd(2) if lettre == "h": penup() goto(x,y+1) setheading(40) pendown() fd(1) rt(60) for i in range(10): lt(20-2*i) fd(1.7) for i in range(10): lt(18) fd(1) fd(14) lt(180) for i in range(7): fd(1.3) rt(25) for i in range(3): lt(30) fd(1) if lettre == "i": penup() goto(x,y) setheading(-15) pendown() for i in range(8): lt(14) fd(1.3) penup() fd(2) pendown() fd(1) penup() setheading(-90)#rt(180) fd(3) pendown() for i in range(6): fd(1.3) lt(15) if lettre == "j": penup() goto(x,y) setheading(-15) pendown() for i in range(8): lt(14) fd(1.3) penup() fd(2) pendown() fd(1) penup() setheading(-90)#rt(180) fd(3) pendown() fd(14) for i in range(8): rt(26) fd(1) for i in range(6): rt(2*i+4) fd(2) if lettre == "k": penup() goto(x,y+2) setheading(40) pendown() fd(1) rt(60) for i in range(10): lt(20-2*i) fd(1.7) for i in range(10): lt(18) fd(1) fd(15) lt(180) fd(3) for i in range(12): fd(1.3) rt(30) rt(90) for i in range(5): fd(1) rt(10) for i in range(4): lt(20) fd(1) if lettre == "l": penup() goto(x,y) pendown() setheading(-10) for i in range(10): lt(20-2*i) fd(2) #lt(6-i) for i in range(5): lt(30) fd(1) for i in range(11): fd(2) lt(2*i+4) if lettre == "m": penup() goto(x,y) pendown() setheading(-10) for i in range(3): fd(0.5) lt(34) fd(5) for j in range(3): for i in range(10): fd(0.4) rt(18) fd(6) lt(180) fd(6) fd(-7) rt(90) fd(2) if lettre == "n": penup() goto(x,y) pendown() setheading(-10) for i in range(3): fd(0.5) lt(33) fd(4) for j in range(2): for i in range(10): fd(0.6) rt(18) fd(5) lt(180) fd(5) fd(-5) rt(90) fd(1) if lettre == "N": penup() goto(x,y+3) setheading(-90) pendown() for i in range(10): fd(1) lt(18) fd(15) rt(145) fd(20) lt(145) fd(15) for i in range(10): fd(1) rt(18)
if lettre == "o": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(4) rt(130) for i in range(30): fd(1) lt(18) for i in range(7): fd(1) lt(35) fd(5) if lettre == "p": penup() goto(x,y) setheading(10) pendown() for i in range(6): fd(1.4) lt(15) setheading(-90) fd(15) fd(-15) lt(90) for i in range(7): fd(1) rt(30-10*i) if lettre == "q": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(4) rt(130) for i in range(30): fd(1) lt(18) setheading(-90) fd(-4)/255 fd(18) fd(-11) lt(80) fd(2) if lettre == "r": penup() goto(x,y+1) setheading(0) pendown() for i in range(8): fd(1) lt(18) setheading(0) fd(5) rt(100) for i in range(7): fd(1) lt(13) if lettre == "s": penup() goto(x,y+1) setheading(0) pendown() for i in range(8): fd(1) lt(18) rt(150) for i in range(8): fd(1) rt(8) lt(30) fd(2) fd(-2) rt(90) for i in range(8): fd(1) rt(12) if lettre == "t": penup() goto(x,y) setheading(-15) pendown() for i in range(8): lt(13) fd(1) fd(9) fd(-3) rt(90) fd(5) fd(-7) fd(2) rt(90) fd(7) for i in range(7): lt(15) fd(1)
if lettre == "u": penup() goto(x,y) setheading(-10) pendown() for i in range(5): fd(1) lt(20) fd(4) rt(180) fd(3) for i in range(7): fd(1) lt(25) fd(5) rt(180) fd(3) for i in range(5): fd(1) lt(20) if lettre == "v": penup() goto(x,y) setheading(45) pendown() for i in range(3): fd(1) lt(15) fd(2) for i in range(5): fd(1) rt(36) fd(3) for i in range(5): fd(1) lt(36) fd(3) rt(110) fd(3) if lettre == "w": penup() goto(x,y) setheading(45) pendown() for i in range(3): fd(1) lt(15) fd(2) for i in range(4): fd(1) rt(45) fd(3) for i in range(4): fd(1) lt(45) fd(5) rt(180) fd(4) for i in range(5): fd(1) lt(36) fd(4) rt(110) fd(1) if lettre == "x": penup() goto(x,y) setheading(80) fd(5) pendown() for i in range(16): fd(1) rt(19) penup() rt(110) fd(9) pendown() rt(240) for i in range(13): fd(1) lt(19) if lettre == "y": penup() goto(x,y) setheading(45) pendown() for i in range(5): fd(1) lt(9) fd(2) for i in range(5): fd(1) rt(36) fd(3) for i in range(5): fd(1.3) lt(36) fd(4) rt(180) fd(14) for i in range(9): rt(19) fd(1) for i in range(5): rt(20-2*i) fd(2) if lettre == "z": penup() goto(x,y+1) setheading(0) pendown() for i in range(8): fd(1) lt(18) setheading(0) fd(6) rt(140) for i in range(6): fd(1) lt(10) rt(180) for i in range(10): fd(0.5) rt(19) fd(10) for i in range(9): rt(19) fd(1) for i in range(3): rt(20-2*i) fd(2) fd(6) if lettre == ".": penup() goto(x+5,y+5) pensize(5) pendown() rt(90) for i in range(5): fd(1) rt(72) pensize(taille_initiale)
def dessin(): hideturtle() penup() goto(-120,70) pensize(3) pencolor([170/255,60/255,60/255]) pendown() setheading(210) for i in range(50): fd(1) rt(6) fd(h_liste) for i in range(50): fd(1) lt(6) for i in range(5): rt(6) fd(-1) setheading(0) fd(l_liste) for i in range(30): fd(1) rt(6) fd(l_liste) fd(-l_liste) for i in range(30): lt(6) fd(-1) fd(-5) lt(90) fd(h_liste-10) for i in range(15): fd(1) lt(6) fd(l_liste)
def liste(): penup() pensize(2) mot="ma liste de N oWl" for rang in range(len(mot)): pencolor([12*rang/255,(255-12*rang)/255,(160+rang*5)/255]) tracer(mot[rang],-95+10*rang,55) pensize(1) #speed(1) mot=". un sapin dEcorE" for rang in range(len(mot)): pencolor([12*rang/255,(255-12*rang)/255,(160+rang*5)/255]) tracer(mot[rang],-100+10*rang,30) mot=". des jolis cadeaux" for rang in range(len(mot)): pencolor([(255-12*rang)/255,12*rang/255,(160+rang*5)/255]) tracer(mot[rang],-100+10*rang,10) mot=". un bon repas" for rang in range(len(mot)): pencolor([(160+5*rang)/255,5*rang/255,(160+rang*5)/255]) tracer(mot[rang],-100+10*rang,-10) mot=". de la neige" for rang in range(len(mot)): pencolor([12*rang/255,(255-12*rang)/255,(255-rang*12)/255]) tracer(mot[rang],-100+10*rang,-30) mot=". une trotinette" for rang in range(len(mot)): pencolor([(160+5*rang)/255,(100-5*rang)/255,(255-rang*12)/255]) tracer(mot[rang],-100+10*rang,-50) pensize(2) penup() goto(70,-40) pendown() setheading(0) fd(1) penup() fd(4) pendown() fd(1) penup() goto(70,-45) setheading(-60) pendown() for i in range(10): fd(1) lt(12)
def etoile(x,y,orientation): penup() goto(x,y) setheading(90+orientation) fd(36) pendown() pensize(2) pencolor([200/255,200/255,0])#jaune doré rt(30) for i in range(5): fd(8) lt(144)
def renne(x,y,orientation): penup() goto(x,y) setheading(orientation) pendown() for k in [-1,1]: penup() pensize(3) goto(x,y) pencolor([140/255,40/255,40/255])#marron setheading(90+orientation-90*k) pendown() for i in range(25): fd(1) lt(5*k) for i in range(3): fd(1) rt(20*k) for i in range(5): fd(1) lt(5*k) rt(70*k)#oreilles for i in range(10): fd(1) rt(5*k) rt(100*k) for i in range(10): fd(1) rt(5*k) rt(100*k) for i in range(10): fd(1) lt(5*k) rt(90*k) #début des bois for i in range(10): fd(1) rt(5*k) for i in range(10): fd(1) lt(10*k) rt(180*k) for i in range(10): rt(10*k) fd(1) rt(70*k) for i in range(5): fd(1) rt(5*k) for i in range(5): fd(1) lt(5*k) for i in range(5): rt(5*k) fd(-1) for i in range(5): lt(5*k) fd(-1) lt(70*k) for i in range(5): lt(5*k) fd(1) rt(90*k) fd(5) fd(-5) lt(90*k) for i in range(5): lt(5*k) fd(1) rt(90*k) for i in range(11): fd(1) lt(8*k) lt(90*k)#remplissage fd(5) pensize(5) lt(40*k) for i in range(6): fd(1) rt(20*k) for n in range(10): fd(1) lt(36*k) for i in range(8): fd(1) lt(10*k) for n in range(10): fd(1) lt(36*k) for i in range(13): fd(1) rt(10*k) for n in range(10): fd(1) lt(36*k) rt(90*k) fd(25) penup() goto(x,y) setheading(90+orientation-90*k) lt(85*k) fd(10) pendown() pensize(5) pencolor([200/255,140/255,140/255]) fd(6)#museau rt(90*k) for i in range(36): fd(1) rt(10*k) lt(90*k) penup() fd(-16) lt(5*k) fd(13) pensize(5) pencolor([255/255,0,0]) pendown() fd(2)#nez rt(90*k) for i in range(20): fd(1) rt(18*k) lt(90*k) penup() fd(9) rt(90*k) fd(4) pensize(3) pencolor([255/255,255/255,255/255]) pendown() lt(90*k) for i in range(3):#blanc oeil fd(1) for i in range(10): fd(1) rt(36*k) penup() pensize(5) pencolor([0,0,0]) fd(-1) pendown() fd(-1)#pupille penup() fd(-1) rt(90*k) fd(11) pencolor([200/255,140/255,140/255]) pensize(3) pendown() fd(1)#creux oreille
def nez_renne(x,y,orientation,couleur): penup() goto(x,y) setheading(orientation+90) fd(14) pensize(5) pencolor(couleur) pendown() rt(90) for i in range(15): fd(1) rt(24) for i in range(20): fd(1) rt(18)
def flocon(x,y,orientation,nb=6,etapes=4): k=5 penup() goto(x,y) setheading(orientation) pendown() pensize(2) pencolor([0,255/255,255/255]) for i in range(nb): for j in range(etapes): fd(k) lt(45) fd(k) fd(-k) rt(90) fd(k) fd(-k) lt(45) fd(-etapes*k) lt(360//nb)
def flocon2(x,y,orientation,nb=6,etapes=4): k=5 penup() goto(x,y) setheading(orientation) pendown() pensize(2) pencolor([0,255/255,255/255]) for i in range(nb): for j in range(etapes): fd(k) lt(45) fd(k) lt(90) fd(3) fd(-3) rt(90) fd(-k) rt(90) fd(k) rt(90) fd(3) fd(-3) lt(90) fd(-k) lt(45) fd(-etapes*k) lt(360//nb)
def flocon3(x,y,orientation,nb=6,etapes=4,angle=30): k=5 penup() goto(x,y) setheading(orientation) pendown() pensize(2) pencolor([0,255/255,255/255]) for i in range(nb): for j in range(etapes): fd(k) lt(45) fd(k) rt(angle) fd(3) fd(-3) lt(angle) fd(-k) rt(90) fd(k) lt(angle) fd(3) fd(-3) rt(angle) fd(-k) lt(45) fd(-etapes*k) lt(360//nb)
def guirlande(x,y,dx,dy,orientation): penup() goto(x,y) setheading(orientation+20) pensize(5) j=0 k=1 while j<dx+dy: for i in range(5): fd(10) rt(8*k) pencolor(choice([[255/255,0,0],[0,255/255,0],[0,0,255/255],[255/255,255/255,0],[255/255,0,255/255],[0,255/255,255/255]])) pendown() fd(1) penup() k=-k j+=12*5
def clignotement(n): for i in range(n): for (x,y,orientation) in [(133,-50,10),(130,60,-30),(-145,25,-30),(-137,-90,-10)]: boule(x,y,10*(2*randint(0,1)-1),5,orientation) nez_renne(175,0,20,[255/255,255/255,0]) guirlande(-117,90,h_liste,0,-90) for (x,y,orientation) in [(133,-50,10),(130,60,-30),(-145,25,-30),(-137,-90,-10)]: boule(x,y,-13,15,orientation) nez_renne(-170,-30,-15,[255/255,255/255,0]) guirlande(103,96,h_liste,0,-90) for (x,y,orientation) in [(133,-50,10),(130,60,-30),(-145,25,-30),(-137,-90,-10)]: boule(x,y,7,22,orientation) nez_renne(175,0,20,[255/255,0,0]) guirlande(-118,86,0,l_liste,0) for (x,y,orientation) in [(133,-50,10),(130,60,-30),(-145,25,-30),(-137,-90,-10)]: boule(x,y,-2*(2*randint(0,1)-1),30,orientation) nez_renne(-170,-30,-15,[255/255,0,0])
cent20, enseignant en Mathématiques et NSI au lycée privé catholique Louis Pasteur à Avignon, a brillamment oeuvré pour que la production de sa classe soit prête dès la date butoir initiale du 7 janvier. Il a en effet demandé à ses élèves de réaliser chacun un petit dessin en DM pendant les vacances de Noël, avec la contrainte qu'il soit compatible avec la bibliothèque turtle de la Graph 90+E. Une fois les DM remis, il lui a suffi de sélectionner les meilleures productions et les intégrer à un unique script. Un grand stratège que ce cent20 !
Ici encore du grand art à la mesure de l'investissement de Casio dans cet événement ; le dessin est encore une fois animé.
cent20 wrote:Nous sommes le 25 décembre, il est précisément 10h42. Dehors il neige, d'ailleurs le bonhomme de Neige construit par les enfants la veille peut être aperçu à travers la fenêtre. Dans le salon, le feu a été attisé, il illumine la pièce pour permettre aux enfants d'ouvrir leurs cadeaux dans une ambiance chaleureuse. Le père noël, qui est passé la veille, a d'ailleurs oublié son bonnet à côté de la cheminée, mais heureusement il n'a pas oublié les cadeaux qui attendent d'être déballés au pied du sapin. Aujourd'hui, c'est Noël !
Voici pour le détail de la construction de l'animation :
Tout petit léger détail, plusieurs appels turtle.pensize() au sein du script utilisent une épaisseur de crayon supérieure à 5, taille non supportée chez Casio. Dans ce cas à l'exécution, la taille est automatiquement ramenée à 5.
# Participation au Jeu concours de Noël de Casio """ Catégorie Classe : Elèves du Lycée Louis Pasteur d'Avignon Professeurs : Vincent ROBERT, Raphaël CLEMENTE Elèves : 15 élèves citées dans ce document, sous la forme Prénom N. (Le listing complet avec les prénoms et photos des carnets vous sera communiqué sur demande, comme prévu à l'article 6 des modalités de participation.) https://www.casio-education.fr/actualites/jeu-concours-casio-de-noel/ """ # ------------------------------------------------------------
# Un projet de classe avec des objets paramétrables """ Ayant découvert ce concours par sur site tiplanet.org, que nous remercions de diffuser régulièrement les annonces des différents constructeurs de calculatrices, nous avons demandé à nos élèves de programmer en python des "cadeaux de Noël". Plus précisément, après la démonstration en classe de la construction d'un sapin de Noël, ils avaient pour consigne de créer une fonction pour rendre la construction de leur cadeau paramétrable afin que l'on puisse le positionner sur l'écran au coordonnées (x,y) et choisir la taille de l'objet. """ # ------------------------------------------------------------
# Importation des librairies nécessaires # ---------------------------------------------------- from turtle import * from math import *
# Une étoile par Rémi A. # ---------------------------------------------------- def etoile(x, y, longueur, epaisseur, couleur_1=(0.81, 0.06, 0.06), couleur_2=(0.98, 0.93, 0.18)): compteur = int(longueur * 1.1) if compteur > 0: if compteur % 2 == 0: coul = couleur_2 else: coul = couleur_1 penup() goto(x, y) pensize(epaisseur) pencolor(coul) pendown() left(8) speed(0) for repetition in range(5): forward(longueur) left(54) forward(longueur) right(126) right(8) etoile(x + 1.45 * epaisseur, y - 0.5 * epaisseur, longueur - epaisseur, epaisseur + 1, couleur_1, couleur_2)
# Un cadeau ouvert par Rémi A. # ---------------------------------------------------- def ruban(x, y, longueur, epaisseur, couleur=(1.0, 0.89, 0.08)): compteur = int(longueur * 0.2) if compteur > 0: penup() goto(x, y) pensize(epaisseur) pendown() speed(0) pencolor(couleur) for i in range(2): forward(4 * longueur) left(120) forward(longueur / 10) right(60) forward(longueur / 10) left(120) ruban(x + epaisseur, y, longueur - 0.5 * epaisseur, epaisseur, couleur)
# Un cadeau fermé par Raphaël C. """Presque un homonyme de l'enseignant, c'est néanmoins un élève""" # ----------------------------------------------------
def cadeauf(x, y, longueur, epaisseur, couleur_n=(0.44, 0.44, 0.44), couleur_fond=(0.94, 0.06, 0.06), couleur_contour=(0.81, 0.06, 0.06)): speed(0) fond(x, y, longueur, epaisseur, couleur_fond) contour(x, y, longueur, epaisseur, couleur_contour) noeud(x, y, longueur, epaisseur, couleur_n) heart(x, y, longueur) penup() right(225) setheading(0)
# Une bougie par Raphaël C. """Presque un homonyme de l'enseignant, c'est néanmoins un élève""" # ---------------------------------------------------- def rect(x, y, long, epai, couleur_r=(0.66, 0.02, 0.02)): penup() goto(x, y) pendown() long2 = 3 * long pencolor(couleur_r) pensize(epai) for i in range(long // 4): for j in range(4): if j % 2 == 0: forward(long) left(90) else: forward(long2) left(90) long -= 4 long2 -= 4
def c_beige(x, y, long, epai, couleur_c=(1, 0.96, 0.83)): c = long // 3.846 pensize(epai * (long / 67.5)) penup() goto(x + long // 2, y + long * 3.06) pendown() pencolor(couleur_c) while c > 1: circle(c) penup() goto(x + long // 2, y + long * 3.1) pendown() c -= 1
def bord_fla(x, y, long, epai, couleur_bf=(0.94, 0, 0.008)): pensize(epai * (long / 100)) penup() goto(x + long // 1.25, y + long * 3.38) pendown() pencolor(couleur_bf) left(90) circle(long / 0.7, long // 1.25) penup() goto(x + long // 5, y + long * 3.38) pendown() right(40) circle(-(long / 0.7), long // 1.25)
def int_fla(x, y, long, epai, couleur_if=(1, 0.54, 0.08)): penup() goto(x + long // 2, y + long * 3.64) pendown() pensize(epai * (long / 41.6)) pencolor(couleur_if) right(45) circle(long / 8.3)
def int_fla_bleu(x, y, long, epai, couleur_ifb=(0.31, 0.49, 0.82)): penup() goto(x + long // 2, y + long * 3.06) pendown() pensize(epai * (long / 41.6)) pencolor(couleur_ifb) circle(long / 16.67)
def mech(x, y, long, epai, couleur_m=(0, 0, 0)): penup() goto(x + long // 2, y + long * 3) pendown() pencolor(couleur_m) pensize(epai * (long // 250)) left(85) forward(long * 0.5)
def bougie_finale(x, y, long, epai): speed(0) rect(x, y, long, epai, couleur_r=(0.66, 0.02, 0.02)) c_beige(x, y, long, epai, couleur_c=(1, 0.96, 0.83)) bord_fla(x, y, long, epai, couleur_bf=(0.94, 0, 0.008)) int_fla(x, y, long, epai, couleur_if=(1, 0.54, 0.08)) int_fla_bleu(x, y, long, epai, couleur_ifb=(0.31, 0.49, 0.82)) mech(x, y, long, epai, couleur_m=(0, 0, 0)) penup() right(90)
# Un flocon par Ethan G. # ---------------------------------------------------- def flocon(x, y, longueur1, longueur2, epaisseur, angle, couleur): pencolor(couleur) pensize(epaisseur) for i in range(9): penup() goto(x, y) pendown() left(angle) forward(longueur1) left(20) forward(longueur2) backward(longueur2) right(40) forward(longueur2) left(60)
# Une cheminée par Aël D. # ---------------------------------------------------- def flamme(x=0, y=0, taille=100, angle=0, couleur="orange", epaisseur=5): right(angle) pensize(epaisseur) pencolor(couleur) penup() goto(x, y) pendown() for i in range(floor(taille / 2)): forward(i) forward(-i) penup() left(90) forward(1) right(90) pendown() for j in range(floor(taille)): forward(floor(taille / 2) - floor(j / 2)) forward(-(floor(taille / 2) - floor(j / 2))) penup() left(90) forward(1) right(90) pendown() penup() goto(0, 0) right(-angle)
# Une guirlande avec des boules par Gabin P. # ---------------------------------------------------- class Boule: def __init__(self, x, y, t, t_pen=1, col_boule="black", col_carre="black", col_triangle="black"): self.x_abs = x self.y_ord = y self.couleur_boule = col_boule self.couleur_carre = col_carre self.couleur_triangle = col_triangle self.taille = t self.taille_pen = t_pen
def affiche_guirlande(self): pendown() self.boule.affiche_boule() if type(self.boule_suiv) is not Guirlande: penup() else: self.boule_suiv.affiche_guirlande()
def clignotement_guirlande(self, couleur, repetition=2): pendown() sens = 0 temp_self = self while repetition != 0: if sens == 0: self.boule.allume_boule(couleur) temp_self = self self = self.boule_suiv for i in range(9999): pass elif sens == 1: self.boule.eteint_boule() temp_self = self self = self.boule_prec
if type(self) is not Guirlande and sens == 0: sens = 1 repetition -= 1 self = temp_self elif type(self) is not Guirlande and sens == 1: repetition -= 1 self = temp_self sens = 0
# Une fenêtre par le prof, les élèves ayant choisi des items plus complexes il me restait la fenêtre ! # ---------------------------------------------------- def fenetre(x, y, longueur=90, hauteur=80, epaisseur=5, couleur=(155 / 256, 114 / 256, 49 / 256)): penup() goto(x, y) pendown() pensize(epaisseur) pencolor(couleur) for _ in range(2): left(90) forward(hauteur) left(90) forward(longueur) left(180) forward(longueur // 2) right(90) forward(hauteur) setheading(0)
# Une haltère par Marius L. # ---------------------------------------------------- def poids(l, Largeur): for i in range(2): forward(l) left(90) forward(Largeur) left(90)
# Propositions non retenue # ---------------------------------------------------- """ Parfois les élèves ont rendu un dessin non paramétrable, que l'on ne peut pas redimensionner. Ils ont participé leur production n'a juste pas été sélectionné pour le dessin final. """ # Marie L. : Le doudou chien & Le sapin de Noël # Baptiste M : Des boules de noël et un bonhomme de Neige # Thomas V. : Une fleur, une voiture # Raphaël M : Une carte mère d'ordinateur # Margot S. : Des livres multicolores fermés # Maxence H. : Yin-Yang # Adam Y. : Une chausette de Noël
# Assemblage final # ---------------------------------------------------- """ Plusieurs secondes sont requises pour réaliser l'assemblage final. En plus du fichier .py, vous ont été fourni : - Une capture d'écran du rendu final - Une vidéo de la construction sur une calculatrice Casio Graph 90+E - Une vidéo de la scène finale """
_Orlando_ participe en tant qu'élève de collège sur fx-92+ Spéciale Collège. Il place la barre extrêmement haut. En effet :
il dessine pas moins de 7 images différentes, images non constituées de formes géométriques simples
et en prime il accompagne cela de quelques inscriptions
Or le langage ne fournit aucune instruction pour faire cela de façon simple, nous n'avons que les déplacements élémentaires de la tortue, même pas de quoi écrire. Qui plus est la taille maximale du script est de 900 octets, franchement pas beaucoup pour stocker les images, de quoi afficher les images, et de quoi afficher les inscriptions.
En pratique les images monochromes sont codées en binaire, et présentes donc sous la forme de gros nombres au sein même du script.
C'est très hautement impressionnant, aux âmes bien nées la valeur n'attend point le nombre des années, toutes nos félicitations !
Aller à x=-2; y=16 S'orienter à 180 degrés -10→E 54→M 73908999719→A 71030273809→B 7→C Répéter 9 39→D Si x=110 Alors Aller à x=-43; y=E 20→M 330302753020→A 5523528707→B 555001849→C Fin Si x=13 Alors Aller à x=-16; y=2E 189875800049→A 36479286949→B 4251023430→C Fin Si x=40 Alors Aller à x=11; y=E 219707870718→A 439093560256→B 2142255588→C Fin Si x=67 Alors Aller à x=38; y=2E 2097016270→A 138480215461→B 2261852748→C Fin Si x=94 Alors Aller à x=65; y=E 549629726467→A A－151674892→B 134415963→C Fin Si x=121 Alors Aller à x=94; y=2E 22→M 479650820087→A 139988187231→B 4262478351→C Fin Si x=150 Alors Aller à x=7E; y=2E 344638079224→A 274872652131→B 487935→C Fin x→F Répéter 117 Si D=0 Alors B→A C→B 39→D Fin D－1→D A÷2→A Si x<F－M＋2 Alors Aller à x=F; y=y＋2 Fin Avancer de ,6 pixels Si A≠Ent(A Alors Stylo écrit Ent(A→A Fin Aller à x=x; y=y＋1 Avancer de 1 pixels Aller à x=x－,4; y=y－1 Stylo relevé ⤴ Aller à x=F＋56; y=8(y－22 185247487863→A 335875282309→B 1→C ⤴
Et voici maintenant _aubin_ toujours sur fx-92+ Spéciale Collège, visiblement un concurrent très dangereux pour ce dernier.
Afficher des cadeaux sur sa calculatrice, c'est trop concret. Ici encore il nous fait ça à la 'meta' / mise en abyme. Il nous rajoute donc une couche intermédiaire en dessinant sur l'écran de la calculatrice une console Nintendo Switch qui affiche elle-même les cadeaux, sélectionnés tout en finesse pour pour faire plaisir à Casio : calculatrice et dictionnaire électronique EX-Word de la marque ; souhaitons-lui que ce soit remarqué et apprécié. Bon, si tout-le-monde a cru se distinguer pour pour finalement faire pareil, l'originalité commence à se discuter...
Ici encore des images sans formes géométriques simples, et visiblement beaucoup plus détaillées que pour la participation précédente. Mais comment est-ce possible alors que cette dernière frôlait déjà la limite mémoire de 900 octets ?
Comme tu peux le voir, le code est anormalement simple :
Aller à x=－96; y=23 Répéter 662 ? →A Répéter jusqu'à A=0 Si x=96 Alors Aller à x=－96; y=y－1 Fin Avancer de 1pixels A－1→A ⤴ ? →A Répéter jusqu'à A=0 Stylo écrit Si x=96 Alors Stylo relevé Aller à x=－96; y=y－1 Stylo écrit Fin Avancer de ,4pixels Stylo relevé Avancer de ,6pixels A－1→A ⤴ ⤴ Stylo relevé Avancer de 193pixels
C'est qu'_aubin_ s'est montré extrêmement malin pour contourner la limite de 900 octets, diabolique même, les données des images ne sont pas dans le script. Ce dernier demande en boucle à l'utilisateur de saisir les données (un fan de input(), cent20 devrait aimer) et c'est donc à Casio de saisir un par un les nombres de la liste communiquée avec la participation. Voici la liste de nombres qu'_aubin_ nous a communiquée :
Malgré une compression RLE sur 1 bit cela fait quand même pas moins de 1324 nombres différents à saisir un par un en attendant à chaque fois la fin du déplacement de la tortue, espérons pour Casio qu'ils ne sont pas nombreux à avoir usé de cette technique, sinon ils seront encore dessus le mois prochain...
Par contre, si c'est bien cette liste exacte qui a été communiquée à Casio, alors c'est extrêmement dommage car il semble y avoir selon nos tests 2 erreurs faisant différer l'affichage de la photo d'_aubin_ partagée plus haut :
une ligne de données semble manquante, réduisant la hauteur des touches haut/bas du pavé directionnel inférieur gauche de la Switch, ainsi que celle de la rangée de touches correspondante sur la calculatrice
un peu après il semble de plus y avoir un décalage des données d'1 pixel horizontal
C'est extrêmement dommage, et nous sommes bien tristes lorsque nous pensons au nombre d'heures qu'_aubin_ a dû passer là-dessus. Espérons que Casio ne le pénalisera pas trop pour ce détail n'enlevant rien au génie de sa participation...
Comme l'année dernière, le niveau sur fx-92+ Spéciale Collège reste très élevé ; c'est fantastique tout ce que l'on peut réaliser avec cette petite machine.
Mais mieux que l'année dernière, tous ceux qui ont bien voulu partager leurs créations sur Graph 90+E jusqu'à présent (et ça fait déjà beaucoup) se sont visiblement donné à fond, désintégrant littéralement les limites de ce qui avait pu être réalisé jusqu'alors en Python sur cette machine !
Nous trouvons que la chose est à la mesure des gros efforts consentis par Casio en dotation pour ce concours, et espérons que ces derniers sont également satisfaits de ce qu'ils ont reçu.
Nombre de jeux sortant pour smartphones, tablettes, ordinateurs et consoles de jeux, se retrouvent plusieurs années plus tard disponibles sur calculatrices graphiques.
Parlons aujourd'hui Casio Graph 90+E, fx-CG50(l'équivalent à l'international), ainsi que fx-CG10 et fx-CG20(les modèles les ayant précédé). Grâce aux émulateurs dédiés NESizm et prizoom par tswilliamson, ces formidables calculatrices te permettent de jouer directement aux jeux compatibles avec les consoles de jeux suivantes :
Nintendo Famicom(1983)
Nintendo NES(1985)
Nintendo Game Boy(1989)
Nintendo Game Boy Color(1998)
Pour les consoles de jeux et plus généralement plateformes ne disposant pas encore d'un émulateur dédié sur ta Casio, les jeux doivent être adaptés au cas par cas. Parmi ces adaptations souvent hautement réussies de jeux sortis pour d'autres plateformes, on peut citer de façon absolument pas exhaustive :
Rappelons en effet que les Casio Graph 90+E et compatibles sont de formidables machines vidéoludiques, aussi bien pour les joueurs que les développeurs, de loin les meilleures à ce jour toute concurrence confondue. En effet le constructeur Casio :
ne bloque pas l'installation d'applications tierces utilisant du code machine forcément non officiel
n'efface pas ces applications à l'activation du mode examen
Un choix de la raison à l'exact opposé de l'ensemble de la concurrence qui pousse pour l'excessif avec l'une, l'autre ou pire les deux restrictions.
Il existe même des consoles de jeux sans aucun émulateur associé, parmi elles les plus récentes ou encore les plus exotiques à la diffusion confidentielle.
Mais inversement, savais-tu qu'il existait également des émulateurs sans console associée ?
La PICO-8 par exemple, à ne surtout pas confondre avec la console Sega Pico, est une console de jeux rétro imaginaire. C'est-à-dire qu'elle est initialement sortie sous la forme d'un émulateur. Il s'agit donc à l'origine d'une machine virtuelle pouvant être installée sur nombre de plateformes, avec ses propres limitations censées stimuler le développement de jeux.
Ecran de 128×128 pixels en 16 couleurs, voilà qui est largement dans les capacités de nos calculatrices, n'est-ce pas ?...
La semaine dernière justement, nous t'annoncions la sortie de CEleste, portage de Celeste, l'un des jeux de plateformes les plus emblématiques de la PICO-8, initialement dévelopé par Noel Berry et Maddy Thorson lors d'une game jam de 4 jours en 2015.
Tu y incarnes donc Madeline, une jeune femme souhaitant gravir le Mont Celeste, une montagne de 2041 mètres située sur l'Île de Vancouver dans l'ouest canadien. À la différence qu'ici la montagne fait 3100 mètres, et que ton ascension sera ainsi découpée en 32 tableaux très exigeants de 100 mètres de dénivelé chacun. Mais pas de game over à craindre ici, chaque chute te ramenant simplement au début du tableau en cours. Madeline peut donc sauter y compris sur les murs verticaux et possède une autre capacité spéciale ; une fois en l'air elle peut effectuer un dash dans l'une des 8 directions à indiquer avec les 4 touches fléchées, de quoi gagner en vitesse et atteindre des zones non accessibles avec un saut normal. Au début du jeu ce mouvement remaquable ne peut être effectué qu'une seule fois par saut ; Madeline aura besoin d'atterrir au sol pour recharger cette capacité, sauf à trouver des cristaux verts flottants qui permettront directement de le faire en vol.
Techniquement, chaque tableau est une grille de 16×16 tiles(tuiles), affichées sur 8×8 pixels chacune.
Le portage CEleste était disponible pour TI-83 Premium CE et TI-84 Plus CE, machines munies d'un écran de 320×240 pixels
Un affichage proche du plein écran est possible avec un facteur de zoom de 2. Cela nécessite donc 256×256 pixels, ce que ne permettent pas les 240 pixels de hauteur de ces machines. La différence de 16 pixels est toutefois faible, il a été décidé d'afficher en zoom ×2 malgré tout. En effet comme visible ci-contre, en centrant bien le tableau on ne perd que la moitié de la hauteur d'affichage des rangées de tiles tout en haut et tout en bas, ce qui ne gêne absolument pas la jouabilité puisque les tiles n'en restent pas moins identifiables.
Mais peut-être disposais-tu justement d'une Casio couleur, jusqu'alors incapable de lancer CEleste ?
C'est vraiment trop injuste...
Et bien tu peux sécher tes larmes de suite Calimero. Lephe et KikooDX ont associé leurs hautes compétences pour corriger cette énorme injustice. Ils te sortent dès aujourd'hui un portage de Celeste pour Graph 90+E et compatibles !
Ici par contre, une difficulté est l'écran de 396×224 pixels. C'est-à-dire que pour un affichage proche du plein écran en zoom ×2, il nous manque pas moins de 32 pixels en hauteur, soit 2 rangées de tiles. Là ce n'est pas possible, masquer 2 rangées risque de faire commettre au joueur des erreurs fatales...
La solution choisie est de t'offrir plusieurs modes d'affichage entre lesquelles tu peux basculer à tout moment avec la touche
F4
:
zoom ×1
zoom ×2 masquant les 2 rangées de tiles tout en bas
zoom ×2 masquant la rangée de tiles tout en haut et la rangé de tiles tout en bas
zoom ×2 masquant les 2 rangées de tiles tout en haut
Autre difficulté, le clavier. Sur Graph 90+E c'est un pavé directionnel peu agréable pour le gaming, et encore pire ici où tu dois pouvoir indiquer à tout moment 8 directions.
Ici aussi, les développeurs ont méticuleusement analysé le problème et fourni une solution. La touche
F5
te permet à tout moment de basculer entre 3 jeux de contrôles sont au choix :
SHIFT
(saut)
ALPHA
(dash)
▲
(↑)
▼
(↓)
◄
(←)
►
(→)(disposition intuitive mais peu agréable, donc)
cos
(saut)
tan
(dash)
OPTN
(↑)
x²
(↓)
ALPHA
(←)
^
(→)
SD
(saut)
■/□
(dash)
cos
(↑)
,
(↓)
)
(←)
→
(→)
Un problème par contre qu'il n'y a pas ici, c'est la puissance matérielle, hautement supérieure à celle d'une TI-83 Premium CE. Donc si c'était parfaitement fluide sur cette dernière, sans surprise cela l'est également ici, même si cela n'enlève rien aux félicitations que nous adressons aux développeurs : :
Un portage absolument remarquable par des développeurs de talent, à inscrire parmi les meilleurs titres de la bibliothèque vidéoludique des Graph 90+E et compatibles !
Pour cette année scolaire 2021-2022, Casio France a fait concevoir des coques personnaliséescollector pour ta calculatrice sur le thème des Mathématiques et des Sciences. Deux superbes visuels sont disponibles et eux-mêmes déclinés en deux formats :
un petit format (coques bleues) convenant à la Graph 35+E II française ainsi qu'à ses équivalents à l'international (fx-9750GIII en Amérique du Nord, fx-9860GIII dans le reste du monde)
un grand format (coques blanches) convenant à la Graph 90+E française ainsi qu'à ses équivalents à l'international (fx-CG50AU en Australie, fx-CG50 dans le reste du monde)
Non disponibles dans le commerce, ces coques sont à récupérer ou gagner lors de divers événements cette année.
D'ailleurs ce n'est pas tout, Casio Allemagne a également lancé cette année une collection de coques personnalisées sur le thème des STEM, mais pour ses calculatrices scientifiques.
Les modèles concernés sont les déclinaisons allemandes du constructeur : fx-82DE X Classwiz, fx-85DE X Classwiz, fx-87DE X Classwiz et fx-991DE X Classwiz. Si jamais tu arrives à récupérer une de ces coques, note qu'elles sont parfaitement utilisables avec les fx-92 Spéciale Collège françaises.
Si c'est cette année une première pour Casio France et également pour Casio Allemagne, précisons que cela ne l'est pas tout à fait pour Casio.
Pour la rentrée 2019, Casio Espagne avait lancé la campagne Classwiz women in science, mettant en avant les femmes dans la science. Le constructeur avait fait appel à des artistes de talent pour réaliser des posters illustrant pas moins de 12 femmes scientifiques ayant marqué l'histoire :
370 : Hypatie illustrée par Conxita Herrero; philosophe, astronome et mathématicienne grecque, bibliothèque d'Alexandrie
1776 : Sophie Germain illustrée par Laura Liedo; mathématicienne, physicienne et philosophe autodidacte française
1815 : Ada Lovelace illustrée par Julia Bereciartu; pionnière de la science informatique avec l'écriture du tout premier programme destiné à être exécuté par une machine, le langage Ada étant nommé en son honneur
1867 : Marie Curie illustrée par Raquel Riba; physicienne et chimiste polonaise naturalisée française, double prix Nobel de Physique et de Chimie pour ses travaux sur la radioactivité
Les calculatrices scientifiques du constructeur ont alors été commercialisées dans des éditions limitées, venant chacune avec un couvercle présentant une version clipart de chaque poster.
Les modèles concernées sont ici les fx-82SP X II Iberia Classwiz et fx-350SP X II Iberia Classwiz(coques noires), fx-85SP X II Iberia Classwiz(coque bleu), fx-570SP X II Iberia Classwiz et fx-991SP X II Iberia Classwiz(coques blanches). Ces coques collector sont toujours parfaitement compatibles avec les fx-92 Spéciale Collège françaises. À noter toutefois ici que chaque visuel n'était pas disponible pour l'ensemble de ces modèles, peut-être entre autres car ne convenant pas toujours aux différentes couleurs de coques.
Une initiative fort louable permettant de promouvoir les carrières scientifiques au plus près des collégiennes et lycéennes !
Et bien grande nouvelle, pour cette année 2021-2022, Casio Espagne rafraîchit sa collection Classwiz women in science. Plusieurs éditions limitées sont effectivement arrêtées (ce qui augmentera la rareté et donc la valeur à la revente), mais deux nouvelles scientifiques nées au siècle dernier apparaissent et en voici ci-contre leurs posters dédiés :
Il est à noter que ce dernier choix d'illustratrice n'est pas un hasard ; Clara Grima avait en effet déjà travaillé avec Raquel Garcia pour les illustrations de plusieurs de ses livres, dont Hasta el infinito y más allá(À l'infini et au-delà) que l'on reconnaît particulièrement bien les visuels de couverture ici. De nouveaux modèles de calculatrices en édition limitée reprennent des versions allégées de ces derniers posters :
Une superbe occasion d'habiller ta géniale fx-92+ Spéciale Collège comme personne d'autre au collège/lycée, ou encore de faire un cadeau qui sera sûrement hautement apprécié à ton prof de maths/sciences préféré !
Lors d'une news précédente, nous vous informions de la réalisation en cours d'un puzzle game intitulé Magic Light sur Casio Graph 90+E par SlyVTT en remerciement du gain de cette machine lors du concours de rentrée 2021.
L'idée du jeu étant aussi fortement liée au thème du concours d'Automne de Planète Casio CPC #28 qui se résumait en un simple mot : GLACIAL et pour lequel un prototype de test avait été implémenté.
Le développement de Magic Light est désormais terminé, et nous sommes heureux de vous en faire une brève présentation, accompagnée de quelques infos supplémentaires.
En effet, depuis la précédente information, de l'eau a coulé sous les ponts, et le développement de la version 1.0 de Magic Light s'est accompagné de la réécriture du jeu pour le rendre compatible avec les TI nSpire CX/CX-II.
Ce n'est donc pas une release que nous annonçons aujourd'hui, mais deux. Oui Madame, vous avez bien entendu, deux versions pour le prix d'une seule.
Magic Light v1.0A pour TI nSpire CX/CX-II (firmware <5.3.0 pour profiter de Ndless) téléchargeable ici http://ti-pla.net/a2832368
Magic Light est un puzzle game et pour le coup une création originale tirant pleinement profit des écrans couleurs de la Graph 90+E et de la TI nSpire CX/CX-II comme nous allons le voir ensemble. Après un menu d'accueil stylé et animé, entrons donc dans le vif du sujet.
Une démo du gameplay sur Graph 90+E est disponible via cette petite vidéo capturé sur l'émulateur :
En tant que héro du jeu, tu te dois ici d'arpenter les différentes salles d'un donjon ... à la recherche des fragments de lumière dérobés aux villageois par le Sorcier Noir et ses 4 Magiciennes de Filles ... afin de ramener couleurs et joie disparues au village. Pour cela, tu dois te rendre dans le chateau forteresse du Magicien où il a caché son butin.
Mais les portes sont fermées et ne peuvent s'ouvrir que si tu résous le puzzle de lumière que te posera chaque salle. Autour de chaque salle sont donc disposés des portes ainsi que des capteurs réagissant à certaines couleurs. Chaque porte est connectée à un certain nombre de capteurs, de 1 à 3, et ne s'ouvre que si ils sont tous éclairés simultanément par les bonnes couleurs.
Pour cela tu disposes dans chaque salle de plusieurs éléments déplaçables avec les touches fléchées du clavier, après les avoir sélectionnés avec les touches ad-hoc correspondant au menu de bas d'écran :
le personnage à faire sortir de la salle
une boule de cristal émettant une lumière blanche, initialement au centre
les blocs filtrant la lumière et ne laissant passer que certaines couleurs : les blocs rouge, vert, bleu et noir
Pour savoir quels capteurs sont associés à une porte, il te faut les éclairer. Un indicateur s'allumera alors au-dessus des portes concernées.
Bien entendu, le château grouille de monstres en tout genre et le Sorcier ainsi que les Magiciennes feront tout pour te dissuader de reprendre leur butin et le ramener au village. Il te faudra donc faire preuve de prudence et de dextérité en plus de jugeote pour traverser cette épreuve.
Le moteur physique codé pour le jeu permet de projeter la forme correcte des faisceaux lumineux sur les murs et les obstacles, mais pas seulement :
selon les niveaux, des blocs fixes peuvent également être présents et bloquer le passage de la lumière
et les blocs filtrant la lumière peuvent être combinés pour former de nouvelles couleurs par synthèse additive
Il vous faudra donc réfléchir à deux fois pour positionner tout ce petit monde à la bonne place, sachant les monstres sont là pour vous embêter et ne vous veulent pas forcément que du bien. Et il ne faudra pas oublier de ramasser les trésors, vous y trouverez des points de vie pour récupérer de la santé, mais aussi des points pour augmenter votre score, et surtout, n'oublions pas le plus important, les fragments de couleurs à récupérer pour sauver le village ...
Les menus devraient être assez clairs pour vous permettre de jouer simplement.
Le jeu offre 3 niveaux de difficulté :
facile : avec 5 points de vie, permet de ne pas galérer
normal : avec 3 points de vie, permet de mieux ressentir la pression des monstres
hardcore : c'est simple, t'es touché ... t'es mort !!
Il vous faudra donc réussir à parcourir les 33 niveaux du jeu et affronter 1000 dangers afin de retrouver les 5 fragments du "Jewel of Colors" et ainsi rapporter la lumière et les couleurs aux villageois.
Bien entendu les deux versions ne sont pas strictement similaires, les machines ayant des spécificité techniques très différentes. Néanmoins, comme visible sur les captures suivantes d'écran issues de la version nSpire, le design a été ajusté au mieux pour adapter le jeu le plus fidèlement possible à la TI nSpire.
Nous vous souhaitons un très bon moment sur Magic Light, en espèrant que vous saurez rapporter la couleur au village.
by 
Collègien(ne), lycéen(ne) ou enseignant(e) en matière scientifique, jusqu'à ce lundi 31 janvier Casio t'a permis de participer à son formidable concours de Noël 2021.
Et en prime avec Casio, pas de perdant : lot de goodies Casio pour tous les autres participants !
Dans la catégorie élèves c'est _Orlando_ le grand gagnant qui pourra donc très bientôt se divertir sur une console Nintendo Switch.
Et voici maintenant _aubin_.
Par contre il semble y avoir selon nos tests 2 erreurs faisant différer l'affichage de la photo d'_aubin_ partagée plus haut :
)
by 
