Description du langage Exper

Attention: rajouter le mot-clé quit à la fin de chaque programme (cela permet de sortir du programme proprement).

Le langage Exper est une suite sequentielle d'instructions interprétées par un programme permettant de les effectuer.
Une instruction peut être:

• une déclaration, modification de variable
• un bloc d'instructions
• un appel à une procédure
• une boucle (for, while)
• un contrôle (if, choose, on)
• un appel à une fonction (print, error, wait, call ...)

La plupart des instructions font appel à des expressions.

Exper permet d'utiliser des variables de 4 types:

• float : nombres réels
• vector : vecteurs
• string : chaînes de caractères
• object : type objet (cf Objets)

On déclare une variable de la façon suivante:

define type nom_variable = expression

Note: les variables de type float peuvent aussi prendre les valeurs booléennes true et false.
On ne déclare une variable qu'une seule fois, elle est ensuite utilisable et modifiable tout au long du programme. La modification se fait par :

set nom_variable = expression
set nom_variable champ = expression pour les champs de variables de type objet

Ex:

define float x = 0.2
define vector v = (1,2,1)
define string s = "hello"
define object k = keyboard
...
set x = true
set k key = "a"

Plusieurs instructions peuvent être regroupées dans un bloc. C'est notamment très utile pour le contrôle choose (cf contrôles).

begin 
  instruction1
  instruction2
  ....
end

On peut regrouper un ensemble d'instructions dans une procédure. Dans la suite du programme un appel à cette procêdure exécutera toutes les instructions qu'elle contient.
Une procédure est définie par:

bloc nom_bloc is
  instruction1
  instruction2
  ...
end

bloc action1 is
        set target position = (2,3,1)
        set target color = "yellow"
        wait(1)
end
 ....
if ( a == true) then
  action1
end

Répétition n fois : boucle for

for expression do
  instruction1
  instruction2
  ...
end

for nom_variable = expression to expression do
  instruction1
  instruction2
  ...
end

for nom_variable = expression to expression step expression do
  instruction1
  instruction2
  ...
end

define float i = 0;
for 5 do
    set i = i+1
    print i
end

for i=0 to 5
    print time()
    wait(1)
end

for i=0 to 3 step 0.5
    print i
end

Répétition selon une condition : boucle while

while expression do
  instruction1
  instruction2
  ...
end

define float x = 2
while (x > 0) do
  set x = x - 1
  print x
end

If

Permet d'exécuter des instructions selon une condition.

if expression then
  instruction1
  instruction2
  ...
end

if expression then
  instruction1
  instruction2
  ...
else
  instruction1
  instruction2
  ...
end

if ( a > 2 ) then
   wait(a)
else 
   print "delay is too short"
end

Choose

Permet de choisir d'exécuter une instruction / un bloc d'instructions parmi plusieurs.

choose expression in
  instruction1
  instruction2
  ...
end

choose random(3) in 
  begin
    set ball color = (1,0,0) // red
    set ball position = (1,3,2)
  end
  begin
    set ball color = (0,1,0) // green
    set ball position = (2,2,2)
  end
  begin
    set ball color = (0,0,1) // blue
    set ball position = (1,3,0)
  end
end

Dans cet exemple, on choisit aléatoirement un bloc d'instructions parmi les 3 qui sont définis.

On

Permet de déclencher un ensemble d'instructions selon un évènement.

on objet nom_evenement do
  instruction1
  instruction2
  ...
end

on sensor "TOUCHED"  do
   print "touched!"
end

print

Ecrit une chaîne de caractères à l'écran.

print nom_variable
print "chaîne de caractères"

error

Ecrit un message d'erreur ainsi que la ligne et le nom du fichier où l'erreur s'est produite.

error nom_variable
error "chaîne de caractères"

cf test_float.exper

break

Permet de sortir d'une boucle de répétition.

define float i = 1.0
for 5 do
  set i = i * 2
  if (i > 10) then
     break
  end
  print i
end

return

Permet de sortir d'un bloc.

return

wait

Suspend l'exécution du programme et attend que l'utilisateur tape [Enter] au clavier si la fonction est appelée sans argument, sinon, la pause dure n secondes, où n est l'argument passé en paramètre de la fonction.

wait()
wait(nombre_de_secondes)

call

Permet d'appeler une fonction d'une variable objet avec ou sans arguments (cf Objets).

call nom_variable_objet nom_fonction
call nom_variable_objet nom_fonction liste_arguments 

Ex:

call player start
call sound play

Les objets permettent d'interfacer les différents périphériques utilisés dans Exper.
Chacun est défini de la façon suivante:

define object nom_variable_objet = type

A chaque type d'objets correspondent des attributs spécifiques (appelés champs) qui peuvent être de type float, vector, string ou object. Les champs sont remplis par:

set nom_variable_objet nom_champ = expression

Ils sont accédés par un simple appel de la forme nom_variable_objet nom_champ
Ex:

define object k = keyboard
set k key = "a"
define string s = k key

Chaque type d'objet dispose également d'un ensemble de fonctions, que l'on appelle via le mot clé call:

call nom_variable_objet nom_fonction
call nom_variable_objet nom_fonction liste_arguments 

La liste des différents types d'objets, de leurs champs et fonctions est donnée ci-dessous.

Expressions float

=> Expressions dont le résultat est un float. Les expressions sont définies par les règles suivantes, où E signifie expression á résultat float, V expression à résultat vector , S expression à résultat string, O expression à résultat objet:

E -> true, false, nombre, nom_variable_float    termes terminaux
     nom_variable_objet champ_float
  -> (E)                                        parenthésage permis
  -> E + E, E - E, -E, E * E, E / E, E % E      op. arithmétiques (% = reste de
                                                la division entière)
  -> E < E, E <= E, E > E, E >= E               op. logiques comparaison
     S < S, S <= S, S > S, S >= S
     !E, E == E, E != E                           non, égalité, non égalité
     V == V, V != V
     S == S, S != S
     E || E, E && E                               ou, et
  -> | E |                                      valeur absolue
  -> | V |                                      norme d'un vecteur
  -> time()                                     met en place une origine de temps au
                                                premier appel, puis donne le temps 
                                                écoulé en s par rapport à cette
                                                origine par la suite
  -> random()                                   valeur aléatoire sur [0..1[
     random(E)                                  valeur aléatoire sur [0..val(E)[
     random(E,E)                                valeur aléatoire sur [val(E)..val(E)[
  -> serial(E)                                  renvoie un compteur incrémenté de 1 
                                                à chaque appel de la fonction; 
                                                compte ainsi de 1 à val(E) et boucle.
     serial(S)                                  utilise les numéros de la chaîne
                                                pour générer une série
  -> xCoord(V), yCoord(V), zCoord(V)            renvoient la valeur de la composante
                                                correspondante du vecteur
  -> sin(E), cos(E)                             sinus et cosinus
  -> floor(E), ceil(E)                          parties entières de flottants
                                                (plus grand entier < E,
                                                plus petit entier > E)
  -> exists(S)                                  renvoie 1 si le fichier existe., 0 sinon

Expressions vector

=> Expressions dont le résultat est un vector. Les expressions sont définies par les règles suivantes, où E signifie expression á résultat float, V expression à résultat vector , S expression à résultat string, O expression à résultat objet:

  
V -> nom_variable_vecteur
     vector nom_variable_objet champ_vector
  -> (E, E, E)                                  construction d'un vecteur
  -> (V)                                        parenthésage permis
  -> V + V, V - V, E * V, V * E                 op. arithmétiques sur les vecteurs
  -> vector nom_variable_vecteur random()       vecteur dont les composantes sont 
                                                tirées aléatoirement sur [0..1[
  -> vector nom_variable_vecteur random(V,V)    vecteur dont les composantes sont 
                                                tirées aléatoirement sur
                                                [Vx..Vx[, [Vy..Vy[, [Vz..Vz[
  -> vector lerp(E,V,V)                         interpolation linéaire, E sur
                                                ]0..1], V1 = origine, V2 =
                                                destination
  -> vector bzerp(V,V,V,V,E)                    évalue les coordonnées 3D d'un
                                                point suivant une courbe de Bezier
                                                definie par 4 points de controle
  -> vector ease(V,V,V,V,V,S)                   ease-in/ease-out interpolation, ease(v1,v2,v3,v4,v5,s) 
                                                v1 = coordonnées du point
                                                (]0..1]), v4 = origine, v5 =
                                                destination, v2 = proportion ([0,1]) du
                                                trajet où l'objet a atteint sa
                                                vitesse maximale (fin de
                                                l'accélération), v3 = proportion                                                du trajet où l'objet commence sa                                                décélération, S = sin ou parab
                                                selon le type de l'interpolation                                                (sinusoidale ou parabolique)  

Expressions string

=> Expressions dont le résultat est une string. Les expressions sont définies par les règles suivantes, où E signifie expression á résultat float, V expression à résultat vector , S expression à résultat string, O expression à résultat objet:

  
S -> "chaîne_caractères",
     nom_variable_string, 
     string nom_variable_objet champ_string
  -> string(E)                                  conversion d'un float en string
  -> string(V)                                  conversion d'un vector en string
  -> S + S                                      concaténation de 2 chaînes
  -> format(S,E)                                

Expressions objets

=> Expressions dont le résultat est un objet. Les expressions sont définies par les règles suivantes, où E signifie expression á résultat float, V expression à résultat vector , S expression à résultat string, O expression à résultat objet :

  
O -> nom_variable_objet, 
     object nom_variable_objet champ_objet
                                 

Dernière mise à jour: 23-06-2016 16:46:05.
Laurence Boissieux, SED, INRIA Grenoble Rhône-Alpes.