Tutoriel NumWorks: Exploiter à son plein potentiel keydown()

[Dogm]

Bonjour,

Hier la team Omega a sortie la mise à jour 1.19 tant attendue basé sur la beta d'Epsilon. Avec celle-ci une nouvelle fonction fort utile a été ajoutée : une fonction keydown() comparable au getkey() du Ti-basic.
Cette dernière étant fort utile pour créer de petits jeux-vidéo ou programmes interactifs.

Ainsi, voici un petit tutoriel pour te permettre d'exploiter à son plein potentiel getkey() .

Le tutoriel se découpera en 3 parties :

Sommaire :Go to top

1. Présentation
2. Variations
3. Optimisation

Présentation :

Go to top

Tout d'abord, avant d'utiliser cette instruction il est nécessaire d'importer le nouveau module ion au début du programme dédié exclusivement à cette fonction : from ion import *

Cette fonction retourne True si la touche k est enfoncée à un instant T, il faudra donc inclure keydown() dans une boucle while de préférence pour bien capter touts les input de l'utilisateur.

Le code en pratique :

Code: Select all

from kandinsky import fill_rect
from ion import keydown

while 1:
  if keydown(KEY_SHIFT):
    fill_rect(0, 0, 320, 240, (255, 0 ,0))
  elif keydown(KEY_BACK):
    break

Explications : la boucle while se répète jusqu'à que la touche back (retour) soit enfoncée, de plus, si la touche shift est pressée un rectangle bleu occupant la totalité de l'écran apparait.

Attention ! Il faut toujours penser à inclure une touche pour quitter ton programme sinon l'utilisateur sera contraint de reset sa calculatrice, perdant ainsi tous ses scripts.

Voici ci-dessous une liste des touches et de leurs correspondances dans le module ion :

Show/Hide spoilerAfficher/Masquer le spoiler

Flèche gauche	KEY_LEFT
Flèche haut	KEY_UP
Flèche bas	KEY_DOWN
Flèche droite	KEY_RIGHT
Touche OK	KEY_OK
Touche maison	KEY_HOME
Touche retour	KEY_BACK
Touche On/Off	KEY_ONOFF
Touche shift	KEY_SHIFT
Touche alpha	KEY_ALPHA
Touche x,n,t	KEY_XNT
Touche var	KEY_VAR
Touche boite à outils	KEY_TOOLBOX
Touche effacer	KEY_BACKSPACE
Touche exponentielle	KEY_EXP
Touche logarithme neperien	KEY_LN
Touche logarithme decimal	KEY_LOG
Touche i imaginaire	KEY_IMAGINARY
Touche virgule	KEY_COMMA
Touche puissance	KEY_POWER
Touche sinus	KEY_SINE
Touche cosinus	KEY_COSINUS
Touche tangente	KEY_TANGENT
Touche pi	KEY_PI
Touche racine carré	KEY_SQRT
Touche carré	KEY_SQUARE
Touche 7	KEY_SEVEN
Touche 8	KEY_EIGHT
Touche 9	KEY_NINE
Touche parenthèse gauche	KEY_LEFTPARENTHESIS
Touche parenthèse droite	KEY_RIGHTPARENTHESIS
Touche 4	KEY_FOUR
Touche 5	KEY_FIVE
Touche 6	KEY_SIX
Touche multiplication	KEY_MULTIPLICATION
Touche division	KEY_DIVISION
Touche 1	KEY_ONE
Touche 2	KEY_TWO
Touche 3	KEY_THREE
Touche plus	KEY_PLUS
Touche moins	KEY_MINUS
Touche 0	KEY_ZERO
Touche point	KEY_DOT
Touche 10 puissance de x	KEY_EE
Touche ans	KEY_ANS
Touche EXE	KEY_EXE

Variations :

Go to top

Une petite variation :

Code: Select all

from kandinsky import fill_rect
from ion import keydown 

while True :
  if not keydown(KEY_SHIFT):
    fill_rect(0, 0, 320, 240,(255, 0, 0))
  elif keydown(KEY_BACK):
    break
  else:
    fill_rect(0, 0, 320, 240, (0, 0, 255)

Ici c'est l'inverse du programme précédant ; tant que la touche shift n'est pas pressée le programme affiche un rectangle rouge. En revanche, quand la touche shift est enfoncée le rectangle se colore en bleu.

Pour acquérir un nombre limité de touches dans un temps donné, on peut coupler une fonction keydown() à la fonction sleep() du module time.
Ce qui nous donne :

Code: Select all

from kandinsky import fill_rect
from time import slee
from ion import keydown

x = 100
y = 100

while 1:
  if keydown(KEY_LEFT):
    x-=10
  elif keydown(KEY_RIGHT):
    x+=10
  elif keydown(KEY_UP):
    y-=10
  elif keydown(KEY_DOWN):
    y+=10
  elif keydown(KEY_BACK):
    break

  fill_rect(x, y, 20, 20, (255, 0, 0,)
  sleep(0.1)

Ce script donne la possibilité de déplacer un carré rouge sur l'écran.
L'instruction sleep() en fin de boucle permet de mettre en pause le programme pendant 0.1 seconde ce qui est très utile pour limiter le nombre de touches acquises et ainsi ralentir ou fluidifier le déplacement de ton objet.

Optimisation :

Go to top

Pour gagner quelques octets, la NumWorks manquant cruellement de stockage, il peut être salutaire de ne pas écrire ==True pour chaque argument.
En effet, l'interpréteur python comprendra et exécutera sans erreur ton programme.
De la même manière, il est possible d'écrire if keydown(k): ou if not keydown(k): à la place de ==False
Une autre technique d'optimisation simple mais très efficace consiste à écrire sur la même ligne les instructions qui suivent une condition.

Ainsi le code

Code: Select all

def Test():
  x=0
  return x

devient:

Code: Select all

def Test(): x=0; return x

Avec toutes ces optimisations le programme précédant ressemble à ceci :

Code: Select all

from kandinsky import *
from time import sleep
from ion import keydown

x = 100
y = 100


while 1:
  if keydown(KEY_LEFT): x-=10
  elif keydown(KEY_RIGHT): x+=10
  elif keydown(KEY_UP): y-=10
  elif keydown(KEY_DOWN): y+=10
  elif keydown(KEY_BACK): break
  fill_rect(x, y, 20, 20,(255, 0, 0))
  sleep(0.1)

Un trop grand nombre de conditions (if, elif et else) avec keydown() comme arguments peut alourdir ton programme et le rendre plus lent.

De manière générale, évites d'afficher un grand nombre d'éléments à l'écran, le frame buffer (fréquence de rafraichissement) de la NumWorks étant très lent.

Voilà, désormais tu as toutes les clefs en main pour intégrer cette fonction dans tes programmes , n'hésite pas à demander de l'aide ou des explications supplémentaires ou même partager tes programmes tirant parti de cette fonctionnalités ici.

Merci à A2drien, redgl0w et M4x1m3 de m'avoir relu et aidé à améliorer grandement ce tutoriel !

---

-Tutoriel d'installation Omega
-Article sur la beta d'Epsilon 13 et les nouveautés d'Omega 1.19

[telpe51]

Super tuto et bien utile pour faire des programmes interactifs !
Merci !

[Dogm]

Merci, c'est un plaisir

Voici une adaptation pour Numworks du célèbre télécran réalisé avec getkey() faite par mes soins

[telpe51]

Encore merci @Dogm pour ton tuto. J'ai eu enfin (!) le temps de le tester ça marche super.
Je propose une variante de ton code qui bouge un carré rouge afin qu'il ne laisse plus de trace (façon "télécran") et qu'il se déplace vraiment.

Code: Select all

from ion import *
from kandinsky import *
from time import *

def depl_car(a=10):
  x,y=100,100
  x0,y0=x,y
  while 1:
    if keydown(KEY_LEFT):
      x0=x
      y0=y
      x-=10     
    elif keydown(KEY_RIGHT):
      x0=x
      y0=y
      x+=10
    elif keydown(KEY_UP):
      x0=x
      y0=y
      y-=10
    elif keydown(KEY_DOWN):
      x0=x
      y0=y
      y+=10
    elif keydown(KEY_BACK):
      break
    fill_rect(x0,y0,a,a,(255,255,255))
    fill_rect(x,y,a,a,(255,0,0))
    sleep(0.1)

Il faut appeler depl_car() ou depl_car(a) où a est la taille du carré (10 par défaut).
Je précise qu'il faut appuyer deux fois sur la touche "retour" pour sortir du programme (une fois pour interrompre le programme et une fois pour retourner à la console).
On pourrait encore l'améliorer en passant la couleur en paramètre par exemple ...
Et bien sûr on pourrait le condenser davantage, mais je trouve que ça serait moins lisible.

[Dogm]

Merci, c'est un plaisir.

T'as version est plus propre en effet, merci.

[Bisam]

On peut quand même condenser ainsi, non ?

Code: Select all

    from ion import *
    from kandinsky import *
    from time import *

    def depl_car(a=10):
      x,y = 100,100
      while 1:
        x0,y0 = x,y
        if keydown(KEY_LEFT):  x -= 10     
        elif keydown(KEY_RIGHT):  x += 10
        elif keydown(KEY_UP):  y -= 10
        elif keydown(KEY_DOWN):  y += 10
        elif keydown(KEY_BACK):
          break
        fill_rect(x0,y0,a,a,(255,255,255))
        fill_rect(x,y,a,a,(255,0,0))
        sleep(0.1)

[Fime]

Merci pour ce tuto, qui est utile pour des debutants. J'avais vu l'utilisation de nombre à la place des variable de ion du type KEY_UP, du genre :

Code: Select all

if keydown(1):
   fonct()


au lieu de:

Code: Select all

if keydown(KEY_UP):
   fonct()