Fichiers :
Les fichiers de scripts du moteur de jeu ELB2d sont de simples fichiers textes. L'extension habituelle est scp, mais toute autre extension peut-être utilisée.
ELB2dScript est un langage interprété et non compilé. L'éditeur permet de déboguer les scripts en autorisant la pause, l’exécution pas à pas du script, ainsi que la visualisation de l'état des variables.
Principe :
Les scripts sont des fichiers textes pouvant être associés à une IA, un sprite de décor, ou être indépendants.
Ils peuvent être déclenchés soit par une interaction avec un perso (touche pressée, collision), soit par une position dans la scène, soit par un chronomètre, soit par un autre script ou encore par le moteur lui même.
Plusieurs scripts peuvent tourner en //. Le principe est qu'à chaque frame du jeu (30 fois par seconde par défaut) chaque commande courante de tous les scripts en mémoire est exécutée. Certaines commandes peuvent bien sûr demander plusieurs frames pour se terminer (cas de la pause par ex).
La version 0.1 supporte :
- déclaration de variables (par simple affectation d'une valeur à une variable de type int, float ou string)
- appel de méthodes et fonctions prédéfinies dans le moteur de jeu (ex : PRINT("Bonjour";0;0) )
- tests sur une ligne ou sur plusieurs lignes
- renvoie par les fonctions de plusieurs valeurs (ex : x;y=getPosIA() )
- labels commençant par ":" (ex: :LABEL)
- les labels sont associés à la commande GOTO (ex : GOTO(LABEL) )
- fonctions arithmétiques de bases : + - / * (limitation : une opération par ligne)
- concaténation de chaînes (ex: mastring="ma "+"chaine")
Remarques :
Les déclarations de variables sont locales au script. Pas de variables globales.
Syntaxe :
La syntaxe est un mélange de C et de Basic.
Les commentaires commencent par # et peuvent se trouver soit sur une ligne seule, soit à la fin d'une ligne de commande.
ex1 : #Exemple de commentaire :
ex2 : x=getPosIAX() #récupère la position x de l'ia courante
Le séparateur de paramètres est ";"
Aucun caractère de fin de ligne n'est requis. Le corollaire est que l'on ne peut avoir qu'une instruction par ligne.
if then else doivent être en minuscule.
Les commandes ne sont pas sensibles à la casse.
Les variables sont sensibles à la casse.
Tests :
ex1 : if (test) then action1 else action2
ex2 :
if (test)
action1
action2
else
action3
action4
endif
test est de la forme : partieGauche < | > | <= | >= | = | != partieDroite
si le test est évalué à vrai alors le then est lancé, sinon le else est lancé.
Dans la forme de if sur une ligne une seule instruction est possible pour then et else.
Dans la forme sur plusieurs lignes il est possible de mettre autant d'instructions que voulues et d'imbriquer un niveau infini de tests.
Blocs :
Les blocs commencent par { et se terminent par }
Leur rôle n'est pas comme en C de délimiter un ensemble d'instructions, mais de grouper toutes les instructions à exécuter dans la frame courante. Par défaut les commandes des scripts sont lancées l'une après l'autre, à chaque frame. L’utilisation des blocs permets de lancer 2 commandes ou plus dans la même frame.
Les blocs doivent être utilisés en connaissance de cause car les performances des scripts peuvent en être altérées (groupement d'instructions lourdes demandant trop de temps de calcul).
Labels / Goto :
Comme en Basic il est possible d'utiliser des labels et des goto pour se déplacer d'un label à un autre.
Les labels commencent par ":" et ne peuvent pas être ifxxx, thenxxx, elsexxx, endifxxx (xxx est un nombre), et ne doivent pas commencer par un chiffre.
Pour se rendre au label :MONLABEL il suffit de placer sur une ligne GOTO(MONLABEL) (sans les : )
Variables :
Le typage des variables est dynamique, le type des variables n'est donc pas déclaré. C'est le contenu de la variable qui déterminera son type.
a=10
b=5,2
c="string"
d=-20
e=a (résultat : e=10)
f=e+10 (résultat : f=20)
g="je suis une "+c (résultat g="je suis une string")
h=c + a (résultat h="string10")
Exemple de script
Remarque : les noms de fonctions sont dans cet exemple en majuscules, cependant il est possible de les écrire sous toutes les formes (minuscules, ou mélange de majuscules et de minuscules). Seules les instructions if, then, else, endif doivent être en minuscule impérativement.
#Création et animation d'un hélico :
#############################################
### Init les données de départ du script
#On crée l'helico :
{
IA(HELICO;3000;210;1;1,4;1,4;100;1;2)
setIDIA(HELICO1)
OMBREIA(1;0;1 250;0,8;0,5;2500)
IA_VISIBLE(1)
IADESTROYONRELOAD(HELICO1;1)
PLAYSON(HELICO;2) #son des pales
bDommages=0
vieMax=getIaLifeMax(HELICO1)
vieDommages=vieMax/2
timerTir=0
}
#On fait avancer l'hélico:
{
KP_INIT(1)
KPG(2;10;0,50;0,50;20;0;-1)
KP(3000;100;1,4;1,4;-10;255;255;255;255;0;0;-1;-1;-1;-1)
KP(1350;210;1,4;1,4;-10;255;255;255;255;0;0;-1;-1;-1;-1)
KP(1289;210;1,4;1,4;-25;255;255;255;255;0;0;-1;-1;-1;-1)
}
#On bloque le script tant que l'hélico n'est pas arrivé à destination:
ATTENDRE_FIN_ANIMKP()
#Helico en surplace une fois arrivé:
{
KP_INIT(1)
KPG(2;4;0,50;0,50;40;0;-1)
KP(1 300;210;1,4;1,4;-30;255;255;255;255;0;0;-1;-1;-1;-1)
KP(1 100;338;1,4;1,4;-35;255;255;255;255;0;0;-1;-1;-1;-1)
KP(1 400;450;1,4;1,4;-30;255;255;255;255;0;0;-1;-1;-1;-1)
KP(1 500;250;1,4;1,4;-35;255;255;255;255;0;0;-1;-1;-1;-1)
}
#############################################
### Boucle principale du script
:GESTION
bVisible=isIaVisible(HELICO1)
if (bVisible=1)
#visible : gestion des dégats sur l'helico
vie=getIaLife(HELICO1)
if (vie<=0)
#mort !
GOTO(MORT)
else
if (bDommages=0)
if (vie<vieDommages) then GOTO(DOMMAGES)
else
#helico endommagé=> les pâles font un bruit avec pause:
PLAYSON(HELICO;1) #son des pales avec ratés
endif
endif
#Gestion du tir: l'helico tire à intervalle régulier sans chercher à viser Mars
if (timerTir>=2)
timerTir=0
IA_TIRER(HELICO1)
else
timerTir=timerTir+1
endif
else
#pas visible => on stoppe le script
GOTO(FINSCRIPT)
endif
GOTO(GESTION)
#############################################
:DOMMAGES
{
INITIADEF(HELICO1)
ADD_OVER(OVER_HELICO_FUMEE;FUMEE_FEU;HELICO1;;0;-110;1;1;15;1;-1)
bDommages=1
}
#On rallie un point commun :
{
KPG(2;6;0,50;0,50;40;0;-1)
KP(1 300;200;1,4;1,4;-15;255;255;255;255;0;0;-1;-1;-1;-1)
}
#On bloque le script tant que l'hélico n'est pas arrivé à destination:
ATTENDRE_FIN_ANIMKP()
#Helico en surplace :
{
KP_INIT(1)
KPG(2;6;0,50;0,50;40;0;-1)
KP(1 300;200;1,4;1,4;-15;255;255;255;255;0;0;-1;-1;-1;-1)
KP(1 300;700;1,4;1,4;-15;255;255;255;255;0;0;-1;-1;-1;-1)
}
GOTO(GESTION)
#############################################
:MORT
{
INITIADEF(HELICO1)
PLAYSON(EXPLOSION)
ADD_OVER(OVER_HELICO_FUMEE2;FUMEE_FEU;HELICO1;;-80;-110;2,5;1,4;15;1;-1)
ADD_OVER(OVER_HELICO_FUMEE3;FUMEE_FEU;HELICO1;;30;-150;1,4;1,1;15;1;-1)
}
#On rallie un point commun :
{
KPG(2;6;0,50;0,50;40;0;-1)
KP(1 300;100;1,4;1,4;-15;255;255;255;255;0;0;-1;-1;-1;-1)
}
#On bloque le script tant que l'hélico n'est pas arrivé à destination:
ATTENDRE_FIN_ANIMKP()
#Coupe le son des pales:
PLAYSON(HELICO;-1)
#Helico en surplace :
{
KP_INIT(1)
KPG(2;50;0,50;0,50;40;0;1)
KP(1 300;100;1,4;1,4;-15;255;255;255;255;0;0;-1;-1;-1;-1)
KP(1 300;930;1,4;1,4;-15;255;255;255;255;0;0;-1;-1;-1;-1)
}
#On bloque le script tant que l'hélico n'est pas arrivé à destination:
ATTENDRE_FIN_ANIMKP()
#Ok, l'helico est au sol : il explose en laissant la carcasse visible !
EXPLOSION("HELICO1";"")
#Animation de mort :
IAANIM(HELICO1;1)
#Coupe toute animation:
KP_INIT(0)
#Le script est terminé, on peut le quitter
GOTO(FINSCRIPT)
##############################
:FINSCRIPT
