[Admin]

jean-baptiste boric avait déjà travaillé à une modification du firmware NumWorks afin d'étendre les possibilités graphiques du module Python kandinsky, lui rajoutant les fonctions :

• draw_line(x1,y1,x2,y2,color) pour le tracer de lignes
• fill_rect(x,y,w,h,color) pour le tracer de rectangles pleins

Dans les deux cas ces fonctions n'étaient pas connectées à la fonction Python setpixel(x,y,color) mais à du code C permettant donc des tracés optimaux, notamment pour le rafraichissement de sprites dans des jeux.

Aujourd'hui jean-baptiste boric poursuit son chemin dans le but de nous permettre enfin de coder en Python des jeux graphiques jouables, en nous diffusant une nouvelle version de son firmware amélioré.

Voyons donc ensemble les dernières nouveautés

A première vue, bizarrement,pas de nouveauté kandinsky.

L'on note toujours comme seuls et uniques ajouts :

• draw_line(x1,y1,x2,y2,color)
• fill_rect(x,y,w,h,color)

Mais histoire d'être sûr, explorons le module kandinsky à l'aide du script suivant :

Code: Tout sélectionner

#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E
def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform=='TI-Python Adapter':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ("HP" in version()))
      except:
        id=2
  return id
 
platform=getplatform()
#lines shown on screen
plines=[29,12,  7, 9,11,0,0]
#max chars per line
#(error or new line if exceeded)
pcols =[53,99,509,32,32,0,0]

nlines=plines[platform]
ncols=pcols[platform]
curline=0

def mprint(*ls):
  global curline
  st=""
  for s in ls:
    if not(isinstance(s,str)):
      s=str(s)
    st=st+s
  stlines=1+int(len(st)/ncols)
  if curline+stlines>=nlines:
    input("Input to continue:")
    curline=0
  print(st)
  curline+=stlines

def sstr(obj):
  try:
    s=obj.__name__
  except:
    s=str(obj)
    a=s.find("'")
    b=s.rfind("'")
    if a>=0 and b!=a:
      s=s[a+1:b]
  return s

def isExplorable(obj):
  s=str(obj)
  return s.startswith("<module '") or s.startswith("<class '")

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      mprint(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      mprint(hd+itms)
  if c>0:
    mprint(hd+"Total: "+str(c)+" item(s)")
  return c

Et bingo, oh que oui il y a des choses, simplement elles ne sont pas listées dans la boîte à outils.

Déjà après les sorties graphiques, Jean-Baptise s'attaque maintenant aux entrées clavier en définissant des codes pour l'ensemble des touches du clavier et rajoutant la fonction get_keys() pour connaître la ou les touches pressées !

Mais ce n'est pas tout, nous avons également de nouvelles fonctions de sorties graphiques :

• get_pixels(x,y,width,data)
• set_pixels(x,y,width,data)
• wait_vblank()

Alors, mission remplie ou pas avec tout ça ? Peut-on enfin coder un Mario pour la calculatrice NumWorks ?

Nous te proposons d'aller juger par toi-même en testant la fluidité du jeu PONG codé par Jean-Baptiste en exploitant ces nouvelles fonctionnalités, premier jeu Python contrôlable au clavier !

Attention au fait que le firmware diffusé par Jean-Baptiste dans ce contexte est basé sur l'état actuel du code source public de la calculatrice NumWorks, et que celui-ci est actuellement en phase bêta de la future version 10.0.0. Des problèmes peuvent donc apparaître même en dehors des points évoqués; il t'est déconseillé de l'installer si tu as de prochains rendez-vous importants (DS, examens, concours...).

Téléchargement : firmware 1.10.0 bêta précompilé avec ces améliorations (installable facilement via webdfu_numworks )
Code : https://github.com/numworks/epsilon/pull/746
Source : viewtopic.php?t=22284&p=239388#p239388

[Admin]

NumWorks travaille actuellement sur la prochaine mise à jour 10.0.0 de sa calculatrice. Celle-ci est déjà disponible en version bêta, à condition de la compiler à partir du code source officiel.

Mais cette fois-ci, une version compilée de la 10.0.0 bêta vient d'être diffusée par jean-baptiste boric dans le contexte de son Python amélioré pour les jeux. Profitons-en donc pour découvrir les nouveautés à venir.

D'une part, nous notons des améliorations apportées au moteur de calcul.

Il est désormais capable de renvoyer des résultats exacts lorsque l'on passe un argument complexe aux fonctions de module et d'argument !

D'autre part, pour la rentrée 2019, selon le nouveau programme de Physique-Chimie de la Seconde Générale et Technologique, il faudra programmer des tracés en langage Python :

• mouvement plan d'un objet ponctuel
• nuage de points
• vecteurs vitesse et variations

La NumWorks est certes le seul modèle à ce jour à disposer d'une implémentation Python constructeur (et donc disponible en mode examen) permettant de dessiner sur l'écran, à l'aide du module kandinsky.

Mais le dernier point évoqué, à savoir représenter des vecteurs, c'est-à-dire une direction, un sens et peut-être même la flèche qu'il y a au bout, n'en reste pas moins un problème trigonométrique bien conséquent, qui ne nous semble pas évident à faire résoudre à un niveau Seconde.
A moins bien sûr de distribuer des fonctions Python précodées par l'enseignant, ce qui n'aura alors pas grand intérêt...

Une fois de plus, le constructeur NumWorks nous prouve sa grande réactivité en n'attendant pas le dernier moment pour apporter une solution, l'inclusion dans son application Python du module turtle développé par jean-baptiste boric en novembre 2018.

Tracer maintenant un vecteur en coordonnées relatives et non absolues, même avec la flèche au bout, n'a plus du tout la même complexité !
C'est doublement une excellente solution à notre problème, puisque c'est également l'occasion de réinvestir les acquis de collège avec le codage de tracés en langage Scratch, mais dans le cadre maintenant d'un langage textuel conformément aux programmes du lycée.

Y sont disponibles des équivalents pour l'ensemble des fonctions Scratch du collège :

De quoi tracer facilement des vecteurs ou même encore plus complexe comme des fleurs !

Code: Tout sélectionner

from turtle import *
import kandinsky

def forbackward(d):
  forward(d)
  backward(d)
 
def pf(d=1,gd=-1,nervure=False):
  n=9
  pos=position()
  for j in range(2):
    for k in range(n):
      forward(d)
      right(gd*90/n)
    right(gd*90)
  if nervure:
    right(gd*40)
    forbackward(5*d)
    right(-gd*40)

def fleur(npetales=8,nfeuilles=2,ltige=160,kfeuille=1,c=kandinsky.color(255,255,0)):
  d=ltige/(nfeuilles+1)
  color(0,191,0)
  for j in range(nfeuilles):
    forward(d)
    pf(kfeuille,2*(j%2)-1,True)
  forward(d)
  color((c>>11)<<3,((c>>5)%64)<<2,(c%32)<<3)
  for j in range(npetales):
    pf(kfeuille,-1)
    left(360/npetales)

#example
from math import *

def hsv2color(h,s=1,v=1):
  c=v*s
  x=c*(1-abs((h%120)/60-1))
  m=v-c
  k=int(h/60)
  r=255*(m+x*(k==1 or k==4)+c*(k==5 or k==0))
  g=255*(m+c*(k==1 or k==2)+x*(k==3 or k==0))
  b=255*(m+x*(k==2 or k==5)+c*(k==3 or k==4))
  return kandinsky.color(round(r),round(g),round(b))

def horiz(y,col):
  for x in range(320):
    kandinsky.set_pixel(x,y,col)

for j in range(112):
  horiz(111-j,hsv2color(210,0+1*j/111,1))
  horiz(111+j,hsv2color(30,.1+.9*j/111,.7))

sw=320
sh=222
ymax=sh/2
ymin=ymax-sh+1
xmin=-sw/2
xmax=xmin+sw-1
penup()
goto(0,ymin)
setheading(90)
pendown()
fleur(12,9,ymax-ymin+1-26,3,kandinsky.color(255,255,0))

Creusons un petit peu la chose, et explorons ce que renferme ce module à l'aide du script suivant :

Code: Tout sélectionner

#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E
def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform=='TI-Python Adapter':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ("HP" in version()))
      except:
        id=2
  return id
 
platform=getplatform()
#lines shown on screen
plines=[29,12,  7, 9,11,0,0]
#max chars per line
#(error or new line if exceeded)
pcols =[53,99,509,32,32,0,0]

nlines=plines[platform]
ncols=pcols[platform]
curline=0

def mprint(*ls):
  global curline
  st=""
  for s in ls:
    if not(isinstance(s,str)):
      s=str(s)
    st=st+s
  stlines=1+int(len(st)/ncols)
  if curline+stlines>=nlines:
    input("Input to continue:")
    curline=0
  print(st)
  curline+=stlines

def sstr(obj):
  try:
    s=obj.__name__
  except:
    s=str(obj)
    a=s.find("'")
    b=s.rfind("'")
    if a>=0 and b!=a:
      s=s[a+1:b]
  return s

def isExplorable(obj):
  s=str(obj)
  return s.startswith("<module '") or s.startswith("<class '")

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      mprint(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      mprint(hd+itms)
  if c>0:
    mprint(hd+"Total: "+str(c)+" item(s)")
  return c

38 éléments donc, soit de quoi chambouler notre classement de la richesse des implémentations de pythonnettes dès la sortie de cette mise à jour !

	TI-Nspire	NumWorks	Casio Graph 90+E	Casio Graph 35+E/USB Graph 75/85/95	module externe TI-Python pour TI-83 Premium CE
builtins	218	188	175	204	190
array	4			4	4
collections					2
cmath	12	12		12
gc	7			7	7
math	41	41	25	41	28
random		8	8	8	8
sys	15			12	15
time		3			4
turtle		38
spécifique	10 (nsp)	5 (kandinsky)			4 (handshake)
Modules	7	7	3	7	9
Éléments	307	295	208	288	262

D'où le classement suivant :

1. TI-Nspire avec 7 modules et 307 entrées
2. NumWorks avec 7 modules et 295 entrées
3. Casio Graph 35+E/75+E avec 7 modules et 288 entrées
4. module externe TI-Python pour TI-83 Premium CE avec 9 modules et 262 entrées
5. Casio Graph 90+E avec 3 modules et 208 entrées

Attention le firmware 10.0.0 téléchargeable ci-dessous est donc en version bêta non finale. Des problèmes peuvent apparaître même en dehors des points évoqués; il t'est déconseillé de l'installer si tu as de prochains rendez-vous importants (DS, examens, concours...).

Téléchargement : firmware 10.0.0 bêta (installable facilement via webdfu_numworks )