Cours sur le LUA.

Voila ici je posterez des cours pour savoir programmer en LUA.


Sommaire :


-Cour n°1: Introduction à la programmation.
-Cour n°2: Affichage de texte à l'ecran.
-Cour n°3: Comment afficher des images.
-Cour n°4: Reconnaissance des touches.
-Cour n°5: Votre premier jeu LUA.
-Cour n°6: Comment faire des screenshots sous lua.
-Cour n°7: Les sauts.
-Cour n°8: Ecriture et lecture d'un fichier.
-Cour n°9: Intoduire le nom d'un joueur.
-Cour n°10: Les collisions.
-Cour n°11: Créer une barre de santé.
-Cour n°12: Tirer des balles (de pistolet).
-Cour n°13: Créer un timer.
-Cour n°14: les tables.
-Cour n°15: Les expressions.
-Cour n°16: Créer ses propres fonctions.
-Cour n°17: Son et music.

Cours n°1 :

Bonjour! Bienvenue dans ce premier cours de programmation lua, consacré aux élémentaires de la programmation.




Pour commencer vous devez savoir que vous n'avez pas besoin de programme spécial pour coder en lua! le bloc-note suffit largement (n'oublier surtout pas d'enregistrer votre code en .lua et non en .txt) mais il existe un environnement de développement propre au lua.
LuaIDE est très facile d'utilisation, voici un screenshot du programme en question:





Bon maintenant que vous savez rendre votre code lisible par le lua player, je vais vous expliquer comment l'utiliser et je vais vous donner une astuce!
Tout d'abord, je vais vous expliquer comment fonctionne lua player, télécharger la version 0.20 pour firmware 1.5 ICI

. Maintenant placer luaplayer et luaplayer% dans le dossier game de votre memory stick.

Ensuite je vais vous montrer comment installer un script lua pour le lire par la suite avec luaplayer.
Dans le dossier luaplayer, se trouve un dossier Applications, dedans se trouve aussi plusieurs jeux, programme en lua deja présents dans le lua player. admettons que vous avez créé un jeux de voiture qui s'appelle "r-rally" et vous voulez le lire avec le lua player, pour ca créer un dossier "r-rally" dans Applications et metter votre script lua MAIS je rappelle que le script doit etre nommé "index.lua".
Voici la hierarchie a respecter:

PSP -->game -->luaplayer%
-->luaplayer -->Applications -->r-rally -->index.lua

Maintenant vous n'avez plus qu'à lancer luaplayer via le menu jeux de votre psp.
Un peux plus haut je vous avais parlé d'une astuce, je vais vous expliquer en quoi elle consiste!
je ne sais pas vous mais moi quand je fais un jeu en lua je trouve plus beau et plus facile de le lancer directement via le menu jeu de la memory stick que de passer par le luaplayer, oui me direz vous mais comment !?
C'est facile tout d'abord télécharger CECI .Une fois téléchargé et extrait vous vous retrouvez avec jeulua et jeulua%, vous devez vous demander ce que c'est? Et bien je vais vous expliquer: l'eboot contenu dans jeulua est l'eboot du luaplayer 0.15, il va vous servir à lancer votre script lua sans passer par l'interface du luaplayer, mais comment?
Enfaite c'est très simple, il suffit de placer votre script lua dans le dossier jeulua et de le nommer script.lua et non plus index.lua. Maintenant dès que vous le lancerez, vous arriverez directement sur votre jeux ou programme lua!







Bonjour bienvenue dans le second cours de XtreamLua, nous allons vous apprendre au fil des cours comment programmer en lua.

Pour se cours, nous allons commencer à afficher du texte sur l'écran, il faut tout d'abord définir une couleur dans une première variable.

rouge = Color.new(255,0,0)

Vous pouvez constater que j'ai donné le nom "rouge", j'aurais très bien pu l'appeler grenadine ou n'importe quel autre nom. Ensuite il y a "Color.new", n'oubliez surtout pas de mettre le "c" de "color" en majuscule sinon vous aurez un très beau message d'erreur. Enfin nous arrivons a la partie "(255,0,0)" ceci est le code de la couleur rouge, je vais vous montrer comment trouver les codes pour toute les couleurs que vous voulez.

Ouvrez paint puis cliquez sur "Couleurs" ensuite sur "Modifier les couleurs", vous obtiendrez une fenêtre comme celle-ci :



Cliquez sur "Définir les couleurs personnalisées >>" voici la fenêtre que vous obtiendrez :



Sur cette fenêtre, j'ai séléctionné la couleur rouge comme dans mon exemple et vous pouvez constater en bas à droite qu'apparait le code de ma couleur "rouge".

Bon maintenant que vous savez définir une couleur on va passer au texte, on va définir une nouvelle variable que l'on va appeller "text" mais on aurait très bien pu lui donner le nom "intro".

text = "Mon premier programme en lua par benja32"

Voila, maintenant que les deux variables sont définies on va afficher le texte à l'écran.

screen:print (150,100,text,rouge)

Bon, maintenant je vais vous expliquer cette ligne de code, surement inconnue pour vous, "screen:print" est la fonction pour afficher du texte sur l'ecran de la PSP. ensuite vous devez vous demander ce que sont les deux chiffres, vous devez savoir que la PSP a un ecran de 480pixel de longueur et 272pixel de hauteur, regardez cette image si vous ne comprenez toujours pas :



Revenons en à nos moutons, 150 est l'endroit ou le texte va commencer sur la longueur de la PSP et 100 est l'endroit ou le texte va commencer sur la hauteur.

Donc maintenant nous avons ce code :

-- couleur (les commentaires sont repéré par deux tiraits en début de ligne)
rouge = Color.new (255,0,0)
-- text
text = "Mon premier programme en lua par benja32"

Maintenant, nous devons ajouter la fonction "screen.flip()".

Cette fonction permet d'intervertir l'état des deux tampons, on parvient donc a faire apparaître le texte à l'écran mais cela ne dure qu'une fraction de seconde.

Pour laisser le texte en continue nous devons introduire une boucle conditionnelle :

"while true do" répète une action tant que la condition est remplie, ensuite on met screen.waitVblankStart() suivit de end pour dire que le code est terminé.

Voici une image de ce que vous obtienez :



Voici le code source complet :

-- couleur
rouge = Color.new (255,0,0)
-- text
text = "Mon premier programme en lua par benja32"
while true do
screen:print (150,100,text,rouge)
screen.flip()
screen.waitVblankStart()
end

Téléchargez le code source complet ici.






Bonjour, bienvenue dans ce troisième cours, aujourd'hui nous allons apprendre comment afficher une image, voir plusieurs, sur l'écran de la PSP puis rajouter du texte par dessus.

Tout d'abords vos photo doivent être au format .png et ne pas
dépasser 480X272 (la taille de l'ecran PSP).

Ensuite on va affichr un background (fond d'ecran) puis rajouter
du texte dessus.

Bon pour commencer on va mettre une variable "bleu": plus
besoin d'explications, vous connaissez maintenant.

bleu = Color.new (0,0,255)

Après on va aller chercher le background

background = Image.load ("background.png")

Image.load permet de charger l'image, n'oublier pas de mettre le "i" de image en majuscule.
Je suppose que vous vous demandez où placer l'image, vous
devez la mettre à côté de votre script.lua
Si vous voulez faire un dossier images pour mettre toutes les
images de votre homebrew vous devrez charger l'image comme ça:

background = Image.load ("images/background.png")

Bon maintenant que l'on a fait ça, on va mettre la fonction pour permettre d'afficher l'image sur l'écran, pour cela on va utiliser screen:blit
donc ce qui va donner:

screen:blit (0,0,background)

Les coordonnées 0,0 sont utilisées pour mettre un background.

Resumé du code :

bleu = Color.new (0,0,255)
background = Image.load ("images/background.png")
screen:blit (0,0,background)

Voici ce qui va apparaitre à l'ecran (la PSP est l'image que j'ai utilisé) :



Maintenant ont va afficher du texte a l'écran donc sur l'image, je vais vous donner un petit truc mais qui est super important si vous voulez voir vos texte à l'ecran!
prenons 2 exemples:

screen:print ( 100, 00," La psp est une console portable génial", rouge)
screen:blit (0,0,background)
et
screen:blit (0,0,background)
screen:print ( 100, 00," La psp est une console portable génial", rouge)

Je crois que vous avez compris que l'exemple numero deux est le bon car si vous faites l'exemple numero 1, le texte sera afficher avant l'image donc l'image "recouvrira" le texte et il ne sera pas perçu a l'écran.
Continuons notre code, nous allons afficher comme texte ceci:

text = "XtreamLua est un site proposant"
text2 = "plusieurs cours de programmation en lua"
screen:print ( 100,100, text, bleu)
screen:print ( 100, 120, text2, bleu)

Voila je crois que vous avez compris le système, voici le code source complet et un screenshot du résultat final :



code source :
-- couleur
bleu = Color.new (0,0,255)
-- image
background = Image.load ("images/background.png")
--text
text = "XtreamLua est un site proposant"
text2 = "plusieurs cours de programmation en lua"

--boucle conditionnelle
while true do
screen:blit (0,0,background)
screen:print ( 100,100, text, bleu)
screen:print ( 100, 120, text2, bleu)
screen.flip()
screen.waitVblankStart()
end

Télécharger le code source complet ici

Bienvenue dans ce cours numero 4.
Aujourd'hui nous allons créer la reconnaissance des touches de votre psp.

Pour commencer notre programme, nous allons définir quelques morceaux de textes :

--text
croix = "La touche enfoncée est la croix"
rond = "La touche enfoncée est le rond"
carré = "La touche enfoncée est le carré"
triangle = "La touche enfoncée est le triangle"
select = "La touche enfoncée est select"
start = "La touche enfoncée est start"
L = "La touche enfoncée est L"
R = "La touche enfoncée est R"
gauche = "La touche enfoncée est gauche"
droite = "La touche enfoncée est droite"
haut = "La touche enfoncée est haut"
bas = "La touche enfoncée est bas"

Nous allons définir une couleur, la rouge par exemple :

--couleur
rouge = (255,0,0)

Ouvrons la boule principale, plaçons l'instruction
screen:clear(), elle va effacer l'écran en permanance, ensuite, créeons une variable (pad) qui contiendra la fonction Controls.read(), cette fonction est utilisée pour stocker l'écoute des boutons dans la variable pad :

--boucle principale
while true do

screen:clear()
pad = Controls.read()

Voici le code complet, analysez le, je vous l'explique en fin de citation :

--text
croix = "La touche enfoncée est la croix"
rond = "La touche enfoncée est le rond"
carre = "La touche enfoncée est le carre"
triangle = "La touche enfoncée est le triangle"
select = "La touche enfoncée est select"
start = "La touche enfoncée est start"
L = "La touche enfoncée est L"
R = "La touche enfoncée est R"
gauche = "La touche enfoncée est gauche"
droite = "La touche enfoncée est droite"
haut = "La touche enfoncée est haut"
bas = "La touche enfoncée est bas"
--couleur
rouge = Color.new(255,0,0)

--boucle principale
while true do

screen:clear()
pad = Controls.read()

if pad:cross() then
screen:print(10,10,croix,rouge)
end

if pad:circle() then
screen:print(10,20,rond,rouge)
end

if pad:square() then
screen:print(10,30,carre,rouge)
end

if pad:triangle() then
screen:print(10,40,triangle,rouge)
end

if pad:l() then
screen:print(10,50,L,rouge)
end

if pad:r() then
screen:print(10,60,R,rouge)
end

if pad:select() then
screen:print(10,70,select,rouge)
end

if pad:start() then
screen:print(10,80,start,rouge)
end

if pad:up() then
screen:print(10,90,haut,rouge)
end

if pad:down() then
screen:print(10,100,bas,rouge)
end

if pad:left() then
screen:print(10,110,gauche,rouge)
end

if pad:right() then
screen:print(10,120,droite,rouge)
end

screen.waitVblankStart()
screen.flip()
end

Bon voyons un petit peu tout ça!
Prenons l'exemple de la touche "start", ce qui donne le code suivant:

if pad:start() then
screen:print(10,10,start,rouge)
end

On a utilisé la boucle conditionnelle if-then-end. Je vais vous traduire cette ligne de code en language litteral :
"Si le bouton start est enfoncé, alors affichez aux coordonnées 10, 10 le message "La touche enfoncée est start" en rouge.
Voila, je suppose que vous avez compris le principe de reconnaissance de touche sur la psp

un screenshot du programme en action:








Bonjour, bienvenu dans ce cours numero 5
Pour bien compendre ce que je vais vous apprendre, vous devez avoir bien lu les 4 cours précédents!

Aujourd'hui je vais vous apprendre les bases pour créer un "mario like", et oui je suis sur que vous avez toujours rêver de programmer un jeux et bien vous pourrez le faire après ce cours

Tout d'abord, chargeons les images dont on aura besoin pour notre jeux.

--images
background = Image.load("background.png")
marioleft = Image.load("marioleft.png")
marioright = Image.load("marioright.png")

"Background" étant le fond d'écran, "marioleft" est l'image de mario regardant vers la gauche et "marioright" celui regardant vers la droite.
Pour le moment rien de bien compliqué, je rappelle une fois de plus que vous pouvez changer le nom de l'image et de la variable.
Maintenant nous allons créer deux variables donnant la position de départ de notre mario, "positionY" étant la largeur de la psp et "positionX" la longeur :

--position de depart
positionY = 210
positionX = 30

Ensuite nous devons définir les touches de notre psp, nous allons utilisé la même méthode que dans le cours n°4 mais bien évidement, avec quelques nouveautés :

if pad:left() then
statut = "left"
x = x+3
end

if pad:right() then
statut = "right"
x = x-3
end

if statut == "left" then screen:blit(positionX, positionY, marioleft)
end
if statut == "right" then screen:blit(positionX, positionY, marioright)
end

Je vais vous expliquer les lignes de codes que je viens d'ajouter, la premiere vous la connaissez, mais vous devez vous demander pourquoi j'ai mis x = x+3 et x = x-3 !? Et bien c'est très simple. Tout d'abord nous devons donner la valeur zero a x donc:
x = 0.
Quand on actionne la touche gauche ou droite, mario ce promènera sur notre écran et avancera de 3 pixel, plus on augmente les pixels, plus mario ira vite!. Maintenant je vais vous expliquer en quoi consiste les statuts.
En premier on va définir les deux statuts que l'on a besoin,
"if statut == "left" then screen:blit(positionX, positionY, marioleft)".
Fe traduis cette ligne de code en language litteral, ce qui donne "si le statut est égal à gauche, alors affiche la positonX,positionY et marioleft".
On fais exactement la même chose pour le statut de droite, vous avez maintenant compris en quoi consiste la création des statuts.
Biensur, il existe d'autre méthode mais je trouve que celle ci est la plus facile et c'est celle que j'ai apprise à mes début. Je vais vous montrer ce qui se passe sans l'utilisation de statut :

if pad:left() then
screen:blit(positionX, positionY, marioright)
x = x+3
end

Quand ont appuira sur la touche de gauche, mario ira vers la gauche mais quand ont lachera toutes les touches, le personne disparaitra.

Si vous essayer votre jeu maintenant, votre mario pourra ce balader de droite à gauche et de gauche à droite évidemment, mais nous avons plusieurs problèmes :
- quand mario arrive aux extrémités de l'ecran, il disparait tout simplement de notre psp.
- il n'y a pas de fond d'écran et le décord ne défile pas, un peu dommage pour un mario

Tachons de résoudre le premier problème, nous allons ajouter quelques lignes de codes :

if pad:left() then
statut = "left"
x = x+3

if positionX>10 then
positionX=positionX-1
end
end

if pad:right() then
statut = "right"
x = x-3

if positionX<462 then
positionX=positionX+1
end
end

Prenons les lignes rajoutées à la fonction left :

if positionX>10 then
positionX=positionX-1

Cela signifie que notre mario sera bloqué à 10 pixel du bord de l'écran gauche, si par exemple vous voulez le bloquer à 3 pixel, remplacer le 10 par un 3.
Maintenant résolvons le deuxieme probleme! Voici le code a rajouter :

screen:blit(x, 0, background)
screen:blit(x+480, 0, background)
screen:blit(x-480, 0, background)
if x == -480 or x == 480 then x = 0 end

Ces 4 lignes signifie que il y aura un défilement du background de 480 vers la gauche et de 480 vers la droite selon le déplacement éffectuer.
Voici une image du jeu finit :

Cours n°6

Bonjour, bienvenue dans ce 6eme cours de programmation LUA. Aujourd'hui nous allons voir quelque chose de très simple mais de très utile pour la préparation de vos homebrew. Prendre des screenshots de vos créations.

Pour commencer insérer cette valeur au début de votre script:

--screenshot
sccnt=1

Encore rien de bien compliqué, ensuite on va inserer la fonction propre au screenshot :

if pad:select() then
screen:save("screenshot/screen"..sccnt..".png")
sccnt=sccnt+1 end

Vous pouvez bien sur changer la touche select par une autre touche de la psp.
N'oubliez surtout pas de créer un dossier "screenshot" à coté de votre script.

Les screenshots s'enregistreront au format .png comme ceci: "screen0", "screen1", "screen2",...







Dans ce tutorial, nous allons vous expliquer comment faire sauter vos personnages.

Je ne vous cache pas que pour certains débutants, ce cours peu s'avérer plutôt dur.

Nous allons créer un personnage simple et un sol, celui-ci pourra
se déplacer de gauche à droite, et sauter (c'est un peu le but du tuto ).

Ce premier bout de code créera seulement quelques couleurs de fond pour le décor

--couleurs
green =Color.new(0,255,0)
white = Color.new(255,255,255)

Le prochain bout de code créera deux images blanche d'orignie, on va leur appliquer les couleurs
crées auparavant, vert pour le sol et blanc pour notre personnage.
Les nombres situés dans les parenthèses indique la taille des images en Pixel (largeur, hauteur).

player1 = Image.createEmpty(32,32)
player1:clear(blanc)

sol = Image.createEmpty(480,10)
sol:clear(vert)

Voici le morceau de code suivant, décortiquez le par vous même et lisez les explications se trouvant à la fin du code :

player = {}
player.gravity = 230
player.y = 230
player.x = 50
player.jumpspeed = 10
player.jumpstate = "au sol"

player.gravity -- > créé une gravité pour eviter que le perso ne reste en l'air.
player.y -- > position vertical du perso sur l'image.
player.x -- > position horizontal du perso sur l'image.
player.jumpspeed -- > la vitesse de saut de notre joueur. cette vitesse sera également employé pour la vitesse de la "chute".
player.jumpstate -- > nous indique dans quel état le joueur est en ce moment. Nous commençons sur la terre (=ground). Nous utiliserons plus tard "jumping" et "falling".

Mainetant, nous allons commencer notre boucle principale, nous allons écrire un code pour déplacer notre joueur de gauche à droite. Analysez se script et lisez les explications :

while true do
pad = Controls.read()
screen:clear()

if pad:left() then
player.x = player.x - 2
end

if pad:right() then
player.x = player.x + 2
end

En gros : Si on appui sur la flèche gauche, alors la position (en X) du joueur diminura de 2.
Si appui sur la flèche droite, alors la position (en X) du joueur augmente de 2.
Nous commençons à avoir quelque chose de concrait
Lisez la suite :

if pad:cross() and player.jumpstate == "sol" then player.jumpstate = "en saut" end

Ce code indique simplement que si le bouton X est préssé et que nous sommes sur le sol (ground), ça ferra sauter (jumping) le caractère.

if player.jumpstate == "en saut" then
player.jumpspeed = player.jumpspeed - 0.5
player.gravity = player.gravity - player.jumpspeed
end

Ce bout de code indique que si nous sommes en train de sauter alors il faudra soustraire 0.5 à notre vitesse de saut (jumpspeed).
Ca signifie que notre vitesse de saut sera plus lente chaque fois que la boucle sera exécuté. Ca aura effet de déplacer notre joueur plus lentement plus il sera loin en l'air et de par ce fait, rendre le saut plus réaliste.
La dernière ligne soustrait la vitesse du saut (jumpspeed) à la gravité (gravity) du joueur.

Voici le prochain bout de code :

if player.gravity < 0 then
player.jumpstate = "retombe"
end

Si la gravité du personnage est inférieur à 0, le caractere sera en etat "retombe", en gros, il retombera sur le sol.

if player.gravity < 230 and player.jumpstate == "retombe" then
player.gravity = player.gravity + (player.jumpspeed + 3)
end

Ce code signifie que si la gravité est inferieur à 230 et que notre joueur est en train de retombé au sol en même temps, alors on additionne la gravité et la vitesse du saut en ajoutant 3 à se dernier [ gravity +(jumpspeed +3)].
Cette action ajoutera 3 à la gravité à chaque boucle, entrainant une chute rapide sur le sol (plus réaliste).

Analysez se code :

if player.gravity == 230 then
player.jumpspeed = 10
player.jumpstate = "au sol"
end

if player.gravity > 230 then player.gravity = 230 end

Ce code signifie que quand notre gravité est à 230 (le niveau du sol) placez alors notre jumpspeed de nouveau à 10, en changeant en même temps l'état de notre perso en "sol".
Notre jumpspeed doit être remit à 10 de sorte que nous puissions à nouveau utiliser l'action "jumping".
La dernière ligne est une sauvegarde. Si notre gravité va à n'importe quel chiffre au dessus de 230, alors ça se remettra automatiquement à 230. C'est le niveau de notre sol donc nous ne devrions pas pouvoir le dépasser.

Maintenant, nous devons placer en position verticale notre personnage, à la hauteur de la gravité.
A chaque boucle la position du personnage en y (verticale) sera identique à ça gravité (player.gravity).
Voici le code:

player.y = player.gravity

Finissons notre code simplement. Nous allons coller l'image du personnage et du sol (que nous avons crées au début de se cour) à l'écran.
Alors nous afficherons par la même occasion les position X et y du joueur et le jumpstate à l'écran (en haut à gauche).

screen:blit(player.x,player.y,player1)
screen:blit(0,262,sol)

screen:print(10,10,"X: "..player.x.." Y: "..player.y,vert)
screen:print(10,20,"Jumpstate: "..player.jumpstate,vert)

screen.waitVblankStart()
screen.flip()
end

Vous pouvez maintenant l'essaier ! Déplacez vous à gauche et à droite, essaier de sauter.
Si vous le voulez, changer les nombres comme bon vous semble si vous voulez voir comment ça affecte les saut.






Dans cette leçon nous allons apprendre comment lire et écrire des fichiers.

Ca peut être pratique dans la programmation de jeux. Vous pouvez l'utiliser si vous avez un gros morceau de code dans un fichier ou pour sauver des informations ou des scores, etc...

D'abord regardons une commande très simple appelée "dofile".
Cette commande lira le code d'un autre fichier et l'exécutera immédiatement.

dofile("./test.lua")

C'est simple non ? Notez que le "./" ne signifie pas que le fichier est dans un sous-dossier.
Si c'était le cas on écrirait :

dofile("./files/test.lua")

Donc si le fichier test.lua contient ce code :

playerx = 10
playery = 20
enemyx = 40
enemyy = 50

Alors, dès que nous allons appelé ce dossier avec la commande "dofile", ces variables seront chargées et délarées.




Lecture d'une ligne dans un fichier :


Prenons un exemple : vous avez un fichier qui contient plusieurs lignes de texte mais vous ne voulez en afficher qu'une sur l'écran.
Dans ce cas nous devons utiliser la commande "io.open()" cette commande ouvre un fichier et le lit ensuite.
Voici la syntaxe : "io.open(filename, mode)".
Pour le mode nous utiliserons "r" pour lire.
Il existe d'autres modes pour "io.open()" :
- r : lecture
- w : écriture (écrase les données existantes)
- a : ajouter (ajoue aux données existantes)
- b : mode binaire
- r+ : met à jour (les données existantes sont gardées)
- w+ : met à jour (les données existantes dont écrasées)
- a+ : ajoute et met à jour (les données existantes sont préservées, ajoute à la fin du fichier seulement)

Tout d'abord il faut ouvrir le fichier et le stocker dans une variable.

file = io.open("testRead.txt", "r")

Maintenant le fichier "testRead.txt" est ouvert et prêt à être lu.
Ensuite, utilisons la commande "read()" pour lire une seule ligne du fichier et la stocker dans une autre variable.

ourline = file:read()

Ceci lira la première ligne de notre fichier texte. La prochaine fois que nous utiliserons la commande "read()" il lira la deuxième ligne, ect...
Notez que nous utilisons le nom de cette variable dans le fichier ouvert avec cette commande.
Il y a aussi des arguments que vous pouvez ajouter à cette commande.
Il vous faut mettre les arguments dans les parenthèses et entre gillemets !
- *n : lire un nombre. ex : file.read("*n")
- *a : lire le fichier entiers de la position actuelle. ex : file.read("*a")
- *l : (par défaut) lire la ligne suivante et renvois une valeur nulle à la fin du fichier. ex : file.read("*l")
- nombre : renvoie le texte de la ligne ou nul à la fin du fichier. ex : file.read(5)

Maintenant que nous avons lu la ligne nous pouvons fermer le fichier :

file:close()

Ensuite maintenant nous allons afficher le texte sur l'écran :

screen:print(10,10,ourline,white)



Lire toutes les lignes :


y = 10
file = io.open("testRead.txt","r")

for line in file:lines() do
y = y + 10
screen:print(100,y,line,white)
end

file:close()

Ce code défini la valeur "y" du départ de l'affichage et il nous faut une valeur "y" différente pour chaque ligne.
Nous ouvrons le fichier.
Regardons la déclaration "for". Cette ligne dit que à chaque ligne du fichier le code entre "do" et "end" est exécuté.
Donc à chaque boucle on ajoute 10 à "y" et on affiche sur l'écran la ligne ce qui fait que chaque ligne sera 10 pixel au dessous de la ligne précédente.



Ecrire dans un fichier (par dessus) :


Ecrire dans un fichier utilise toujours la même méthode. Ici nous allons écrire mais en effaçant les données précédentes.

file = io.open("testRead.txt","w")
file:write("hello")
file:close()

Remarquez que cette fois nous avons utilisé le mode "w" au lieu de "r" pour écrire et non lire.
Nous utilisons la commande "file:write()" avec le texte que nous voulons écrire dans le fichier dans les parenthèses et entre guillemets. On peut aussi utiliser une variable à écrire dans le fichier mais elle ne seras pas entre guillemets.
Exemple :

file = io.open("testRead.txt","w")
myText = "Hello"
file:write(myText)
file:close()



Ecrire dans un fichier (ajouter à la suite) :


Vous pouvez utiliser le mode "ajouter" pour écrire du texte à la suite du fichier au lieu de l'écraser. On utilise toujours la même méthode sauf que au lieu d'utiliser le mode "w" nous utilisons le mode "a".

file = io.open("testRead.txt","a")
myText = "Hello"
file:write(myText)
file:close()

Vous trouvez que c'est différent ? Dans la variable "myText" nous avons rajouté "
" dans la chaîne de caractère. Cette commande sert à aller à la ligne comme la touche "Entrée". Cette commande est aussi utilisée dans le C ou C++.

Dans cette leçon, nous allons voir comment faire une fenetre pour introduire un nom de joueur.

Nous allons donc enregistrer le nom du joueur dans une variable. Le joueur doit pouvoir mettre son nom en majuscule et en minuscule.

Pour commencer, nous allons créer 2 couleurs utilisées pour le texte et la sélection.

white = Color.new(255,255,255)
red = Color.new(255,0,0)

Maintenant pour afficher et être capable de taper les lettres à l'écran, nous devons créer un alphabet.
Donc nous allons créer une nouvelle varaibles où nous stockerons tout l'alphabet.
A la fin de cette variable, nous mettrons un "espace" que le joueur pourra utiliser pour son nom.

characters = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", " " }

Maintenant nous devons assigner une variable à chaque lettre de l'alphabet.
Exemple:
la lettre "a" correspond a [1], la lettre "b" a [2], etc...
Avant, nous devons créer une image vide de 10 x 10 pixels, nous colorerons cette image en rouge.
Cette petite image rouge sera utilisée pour marquer l'emplacement du curseur. Il devra bouger à chaque fois que le joueur choisira une lettre.

selector = Image.createEmpty(10,10)
selector:clear(red)

Ensuite nous allons créer 2 variables x et y qui serviront à positionner les lettres à l'écran :

charX = 100
charY= 100

Puis nous allons créer 2 autres variables qui seront utilisées pour positionner le curseur :

currentX = 107
currentY = 98

Nous allons créer une variable où sera stocké le nombre correspondant à la lettre sélectionnée, donc si le joueur choisi la lettre "c", la variable devra etre "3". Puis nous allons ajouter une incrémentation quand le curseur ira à droite et une désincrémentation quand le curseur ira à gauche de facon à faire correspondre le chiffre à la lettre.

currentLetter = 1

Après ca, nous devrons aussi créer 2 autres variables : une pour la sélection majuscule/minuscule (elle sera du type "true" or "false" et une autre pour le nom du joueur que nous allons déclarer comme vide au début nous aurons aussi besoin du pad pour choisir les lettres :

uppercase = true
name = ""
oldpad = Controls.read()

Encore 3 variables de plus pour afficher les lettres:

addX = 0
addY = -10
addRow = -9

Maintenant nous allons créer une nouvelle fonction qui servira à créer une boucle pour afficher les lettres sur l'écran:

function drawLetters()
for a = 1, 3 do
addX = 0
addY = addY + 10
addRow = addRow + 9
for b = 1, 9 do
addX = addX + 10
if uppercase == false then
screen:print(charX + addX,charY + addY, characters[b + addRow],white)
else
screen:print(charX + addX,charY + addY,string.upper(characters[b + addRow]),white)
end
end
end
addX = 0
addY = -10
addRow = -9
end

Première chose, nous créeons une boucle, "a" va de "1" a "3" car nous allons créer 3 lignes de lettres à l'écran, nous avons 26 lettres + le "espace", donc nous ferons 3 lignes de 9 charactères chacune.
Le code "for a = 1, 3 do" crée une boucle qui éxécute chaque fois (3 fois) une nouvelle ligne d'affichage.
"addX" commence a 0.
"addY=addY + 10" commence à 0 et sera incrémenté de 10 à chaque fois (normal un caractere fait 10 pixels).
"addRow=addRow +9" mets un compteur à 9 (nombre de caracteres par ligne).
"for b=1,9" permet de mettre 9 caracteres par ligne.
"addX =addX+10" incéremente de 10 a chaque fois(un caratere fait 10 pixels).
Ensuite on vérifie si la lettre est en majuscule ou en miniscule
en cas d'utilisation de majuscule la fonction "string.upper" convertie les minuscules en majuscules.
"characters[b+addRow]" permet d'afficher tous les characteres un par un.
A la fin de la boucle, on remet les 3 variables utilisées à zero pour une prochaine utilisation.

Désolé si vous êtes un peu perdu mais c'était la partie la plus compliquée du cours à expliquer.

Maintenant on va s'occuper de la boucle principale:

while true do
pad = Controls.read()

screen:clear()

screen:print(10,10,"Enter Name: "..name,white)
screen:blit(currentX,currentY, selector)

drawLetters()

On attaque les choses sérieuse : le moment où l'on appuie sur la croix directionnelle.
Commencons par nettoyer l'ecran, ensuite on affiche le message "entrer votre nom" à l'écran, dessous on va afficher la variable où le nom du joueur est stocké, finalement on appelle la fonction "drawLetters()" qui va afficher l'alphabet (mais si, c'est ce que l'on vient de faire juste avant):

if pad:cross() and oldpad:cross() ~= pad:cross() then
if uppercase == false then
name = name .. characters[currentLetter]
else
name = name .. string.upper(characters[currentLetter])
end
end

Ensuite on va faire en sorte qu'appuyer sur "X" sélectionne un caractere puis on va voir si les majuscules sont sélectionnées ou non.

Bon maintenant, il se peut que le joueur fasse une erreur en écrivant son nom, on va donc ajouter une fonction permettant de corriger une faute avec la touche "carré":

if pad:square() and oldpad:square() ~= pad:square() then
name = string.sub(name, 1, string.len(name) - 1)
end

La premiere ligne teste quand la touche "carré" est appuyée ou pas. La 2eme ligne permet d'effacer le caractere dans la variable "name".
L'instruction "string.sub() nécessite 3 arguments: le 1er est le nom de la variable à modifier, le 2eme est en fait le nombre de
caractere à supprimer dans la variable du 1er, le 3eme est l'emplacement du caractere à supprimer.

Maintenant nous allons voir comment sélectionner les majuscules/minuscules avec la touche "triangle"
le fait d'appuyer sur "triangle" change la position (true or false) de la variable "uppercase".

if pad:triangle() and oldpad:triangle() ~= pad:triangle() then
if uppercase == false then
uppercase = true
else
uppercase = false
end
end

Maintenant on va voir comment déplacer le curseur pour sélectionner le caractere:

--MOVE SELECTOR RIGHT :

if pad:right() and currentLetter ~= 9 and currentLetter ~= 18 and currentLetter ~= 27 and oldpad:right() ~= pad:right() then
currentLetter = currentLetter + 1
currentX = currentX + 10
elseif pad:right() and oldpad:right() ~= pad:right() then
if currentLetter == 9 or currentLetter == 18 or currentLetter == 27 then
currentLetter = currentLetter - 8
currentX = 107
end
end

En premier, il faut vérifier quand le bouton "droit" de la croix directionnelle est appuyé.
Ensuite, il faut s'assurer que le curseur restera sur les caractères affichés (qu'il n'aille plus à droite quand il n'y a plus
de cracateres), bref qu'il ne dépasse pas la position 9, 18 ou 27.

Et pour finir, faisons pareil pour aller à gauche , en bas et en haut:

-- MOVE SELECTOR LEFT
if pad:left() and currentLetter ~= 1 and currentLetter ~= 10 and currentLetter ~= 19 and oldpad:left() ~= pad:left() then
currentLetter = currentLetter - 1
currentX = currentX - 10
elseif pad:left() and oldpad:left() ~= pad:left() then
if currentLetter == 1 or currentLetter == 10 or currentLetter == 19 then
currentX = 107 + 80
currentLetter = currentLetter + 8
end
end

-- MOVE SELECTOR DOWN
if pad:down() and currentLetter < 19 and oldpad:down() ~= pad:down() then
currentLetter = currentLetter + 9
currentY = currentY + 10
elseif pad:down() and currentLetter > 18 and oldpad:down() ~= pad:down() then
currentY = 98
currentLetter = currentLetter - 18
end
-- MOVE SELECTOR UP
if pad:up() and currentLetter > 9 and oldpad:up() ~= pad:up() then
currentLetter = currentLetter - 9
currentY = currentY - 10
elseif pad:up() and currentLetter < 18 and oldpad:up() ~= pad:up() then
currentY = 118
currentLetter = currentLetter + 18
end

Et enfin, on cloture le programme:

screen.flip()
screen.waitVblankStart()
oldpad = pad
end

Se tutorial va vous apprendre à créer une simple collision en LUA.

Nous emploierons la méthode box collision, ça ne sera donc pas une collision parfaite de Pixel.
Ce tuto etant surement votre première approche des collision, ça restera assez simple.

La petite démo que nous allons créer tout au long de se tuto nous donnera un joueur (un carré) mobile.
Il y aura également trois blocs sur l'écranc ce sont ces blocs qui auront des collisions mise en place.
Le joueur ne pourra donc pas marcher sur ces blocs.

Nous allons tout dabord céer deux couleurs differents, une pour le joueur et l'autre pour les blocs :

vert = Color.new(0,255,0)
blanc = Color.new(255,255,255)

Maintenant, nous allons créer des images pour les utiliser comme notre joueur et nos blocs.
D'abord nous créons des blocs de 32x32 vides et nous leur appliquons les couleurs que nous avons créées plus haut :

player = Image.createEmpty(32,32)
player:clear(white)

block = Image.createEmpty(32,32)
block:clear(green)

Maintenant, nous allons positionner notre perso (en indiquant les valeurs X et Y):

Player = { x = 30, y = 100 }

Ensuite, nous devons définir deux variables qui stockeront la hauteur et la largeur de l'image de notre joueur.
Ces valeurs seront employées dans notre fonction "collision". Rappelez-vous que nous avons créé nos
images en 32x32, donc, nous utiliserons ces valeurs :

playerHeight = 32
playerWidth = 32

Maintenant, nous allons positionné les trois blocs que nous avons créé au préalable.
Naturellement, nous stockerons les valeurs de x et y pour chaque bloc de sorte que nous ayons un endroit
pour les mettre sur l'écran. Nous stockerons également la largeur et la hauteur des blocs disposé.
Nous emploirons les commandes width() et height() qui trouve automatiquement ces valeurs pour nous.
Les valeurs sont prises de l'image des bloc que nous avons créée plus tôt! Faites comme suit :

Block = {}
Block[1] = { x = 100, y = 80, height = block:height(), width = block:width() }
Block[2] = { x = 300, y = 30, height = block:height(), width = block:width() }
Block[3] = { x = 200, y = 58, height = block:height(), width = block:width() }

Maintenant, nous allons créé une fonction pour déplacer notre joueur autour.
Cette fonction s'appellera à chaque boucle qui vérifie les mouvements :

function movePlayer()
pad = Controls.read()
if pad:left() then
Player.x = Player.x - 1
end
if pad:right() then
Player.x = Player.x + 1
end
if pad:up() then
Player.y = Player.y - 1
end
if pad:down() then
Player.y = Player.y + 1
end
end

Il est maintenant temps de créer une fonction qui vérifiera si une collision est en cours.
Cette fonction nous permettra d'ajouter des collisions à n'importe quel objet que l'on veut dans notre jeu, aussi longtemps que cette fonction sera réclamée dans notre boucle. Jetez un coup d'oeil à la fonction entière :

function collisionCheck(object)
if (Player.x + playerWidth > object.x) and (Player.x < object.x + object.width) and (Player.y + playerHeight > object.y) and (Player.y < object.y + object.height) then
Player.x = oldx
Player.y = oldy
end
end

Jetez un coup d'oeil à la première ligne : "function collisionCheck(object)"
Ceci crée notre fonction que nous avons appelée collisionCheck.
Nous avons noté à l'intérieur des parenthèses le mot "objet".
Ce mot est en faite une variable "factice".Quand nous utiliserons
réellement notre fonction plus tard nous remplacerons ce mot avec le nom de l'objet auquel nous déterminerons une collision. Si vous regardez à l'intérieur de la fonction vous noterez que le mot "objet apparaît plusieurs fois.
Quand cette fonction sera appeler, tout les mots "object" seront automatiquement remplacé par le noms des objets utilisant cette fonction.

La deuxième ligne est épatante, ne trouvez vous pas?? Nous avons l'argument if qui vérifie plusieurs conditions. La premiere condition est celle-ci :(Player.x + playerWidth > object.x).
Pour rappel, la valeur en X d'une images est toujours situé dans le coin supérieur gauche de l'image.
Normalement ce que nous allons faire doit créer comme un secteur que l'on ne peu pas franchir autour de l'image, une collision en faite.
Donc, si vous vous approchez de se secteur , la collision devrait se produire. Voici quelques images que vous pouvez regarder pendant que nous travaillons sur ces lignes de code.

La boîte bleue represente le bloc immobile, et la boîte rouge le joueur. La ligne noire schématise l'endroit ou la collision se produit. Jusqu'ici nous avons seulement vérifié si le bon côté
de notre joueur dépasse la valeur x de notre autre objet.
Regardez ci-dessous :



Comme vous pouvez le voir, à ce moment la, notre joueur est à l'intérieur de la zone de collision.

Après nous avons une autre condition : (Player.x < object.x + object.width).
Cette condition créé une collision sur le bloc quand vous essaier de passer sur le côté droit de ce bloc.
Ca fait donc l'inverse de la condition que l'on a vu avant. Voyont se que ça donne avec un petit schéma



Nous sommes toujours dans la zone de collision. Avec ces deux premieres conditions nous devons être entre les lignes pour que la collision se produise.
La prochaine condition : (Player.y + playerHeight > object.y).
La position Y du joueur ajoutée à la hauteur du joueur nous donne la position des "pieds" du joueur (vous comprenez
bien que le personnage, etant un carré, n'a pas de pied mais c'est plus facil à expliquer comme ça ).
Si cette valeur est plus grande que la position des objets y, alors nous nous heurtons aux blocs.
Voyons maintenant le schéma avec ces 3 conditions rempli :



Voici la derniere condition à remplir : (Player.y < object.y + object.height)
Si la valeur en Y du joueur est plus petit que le fond de l'objet (plus la hauteur de l'objet en Y) alors nous nous heurtons aux blocs.
Nous utilisons le signe < cette fois si car si sur l'écran nous montons, la valeur Y diminue Voyez maintenant le scema final :



Maintenant la partie inférieurs du bloc n'est plus en zones de collision. Le seul secteur qui est maintenant en zone de collision est le bloc tout entier (donc 36X36). Avec nos quatre conditions remplies, la collision entourent seulement le bloc.
Maintenant, nous renommons oldx et oldy en Player.x et Player.y. Nous n'avons pas encore défini les valeurs de oldy et oldx.
C'est la première chose que nous ferons dans notre boucle principale. Si la fonction détermine que nous sommes à
l'intérieur de ce secteur de collision alors il nous placera de nouveau à la dernière position dans laquel nous étions,
qui est stockée dans oldx et oldy. C'est ça qui nous donne l'illusion de ne pas pouvoir allez dans le bloc.
J'ai essaier de vous détailer le plus possible la fonction "collision" mais si malgré ça, vous n'avez pas tout comprit,
le forum est la pour ça

Maintenant, on créé la boucle principale. Je ne la résumerai pas car le but de se tuto est déjà atteind :
while true do

-- store player's position at beginning of each loop
oldx = Player.x
oldy = Player.y
screen:clear()

movePlayer()

--check collision for each block
collisionCheck(Block[1])
collisionCheck(Block[2])
collisionCheck(Block[3])

--paste player to screen
screen:blit(Player.x,Player.y,player)

--paste all 3 blocks to screen
for a = 1,3 do
screen:blit(Block[a].x,Block[a].y,block)
end

screen.waitVblankStart()
screen.flip()
end

Bonjours à toutes et à tous, se cours va vous apprendre à réaliser une barre de santé pour vos futurs personnages.

La création d'une barre de santé est un critère important dans la plupart des jeux.

Pour un programmeur débutant, ça peu vite être prise de tête et plus dur qu'on ne le pense!!
Mais c'est un processus très simple une fois que vous connaisaient les différents manières dans laquel la barre peut être faite. Commençons à coder.

En premier, créons deux couleurs. Nous utiliserons le rouge pour la barre et le blanc pour imprimer à l'écran un texte.

red = Color.new(255,0,0)
white = Color.new(255,255,255)

Ensuite, nous créerons des rangées pour stocker les informations de la barre et du joueur.
Notre première rangée est pour la barre de santé. Nous allons créer la rangée et lui ajouterons un type qui se référera à la position en Y de la barre de santé :

healthbar = {}
healthbar.y = 10

Maintenant, nous créons une rangée pour notre joueur. Dans notre exemple, nous devonsajouter une rangée pour la santé (en pourcentage) du joueur.

player = {}
player.health = 100

Maintenant, nous commençons notre boucle principale :

while true do
screen:clear()
pad = Controls.read()

Maintenant que nous avons commencé notre boucle principale, nous allons créer la partie de notre programme qui fera à plusieurs reprises la vérification et les mises à jour nécessaires
(si par exemple, de l'energie est perdu ).

Notre prochaine ligne de code dessinera le barre à l'écran. Nous utiliserons la commande "drawRect" pour faire ça. Cette commande dessine simplement un rectangle entier. Voici le code.
Jetez y un coup d'oeil et je vous le détaillerez à la suite :

screen:fillRect(10,10,player.health,healthbar.y,red)

Cette commande peu être utilisée pour dessiner un rectangle sur une image.
Mais à la place nous la dessinerons sur l'écran, en haut à gauche. Les deux 10 sont la position en x et y ou nous dessinerons le rectangle. Les deux prochains arguments sont les rangées que nous avons créées plus tôt.
"player.health" sera la largeur du rectangle.
"healthbar.y" sera l'épaisseur du rectangle, sa valeur est défini plus haut, à 10.
Il ne faudra jamais la changer . Mais si vous le voulez, vous pouvez changer la valeur en y au lieu de la valeur en x si vous vouliez une barre plus longue verticalement.

Nous allons imprimerons la santé en % du joueurs à l'écran, sous la barre de santé, ainsi vous pourrez voir la santé visuellement avec le texte et graphiquement, avec la barre rouge :

screen:print(10,30,player.health,white)

Maintenant, pour notre exemple, nous allons faire augmenter la santé si le bouton haut est maintenu, et diminuer la santé si le bouton bas est maintenu :

if pad:up() and player.health < 100 then
player.health = player.health + 0.5
end

Ce code augmentera la santé du joueur de 0.5 si le bouton haut est poussé, et que la santé du joueur est de moins de 100 puisque notre santé va seulement juqu'à 100.
Maintenant, faisons la même chose mais pour le bouton bas :

if pad:down() and player.health > 0 then
player.health = player.health - 0.5 end

Ce code est le même que le précédent sauf que la santé diminuera si maintenez la touche bas, en considérant que notre santé est à plus de zéro. Sans cette limite à zéro, notre santé serrait passer en négatifs !

Finissons notre boucle et concluons ce cours :

screen.flip()
screen.waitVblankStart()
end

Ce exemple de programme va vous apprendre à créer (tirer) de multiples balles en appuyant sur le bouton X .
Les balles seront créées où le joueur se tiendra. je détaillerai le plus possible chaque section de code.

Notre premier morceau de code créra simplement deux objets de différentes couleur à utilisé dans notre programme.

--Create colors
green=Color.new(0,255,0)
white = Color.new(255,255,255)

La prochaine section de code créera deux images blanche, on va appliquer à ces images du vert pour l'une et du blanc pour l'autre.
Une image sera notre caractère, l'autre une balle. Les nombres dans les parenthèses représente la taille de l'image en Pixel (largeur, hauteur).


--Create a blank image and fill it with green. This will be our bullet.
bullet = Image.createEmpty(4,4)
bullet:clear(green)

--Create a player.
player = Image.createEmpty(32,32)
player:clear(white)

Maintenant, nous allons créér trois variables. "Oldpad" sert à vérifier notre derniers entrée, "cuurentBullet" nous indique les balles en cours de tire, et "direction", nous indique dans quelle direction notre joueur fait face.

--Variables
oldpad = Controls.read()
currentBullet = 0
direction = "right"

Après, nous créerons deux rangées. La premiere crée simplement une rangée de joueur dans laquelle nous stockerons la position en X et Y du joueur. La deuxième (BulletInfo) est assez compliqué, regardez dabord et j'éxpliquerai apres :

--Player Array
Player = {}
Player[1] = { x = 30, y = 100 }

--Create Array for Bullets
BulletInfo = {}
for a = 1,5 do
BulletInfo[a] = { pic = bullet , firing = false, direction = "right", x = Player[1].x + 32,
y = Player[1].y + 16 }
end

La rangée BulletInfo stocke les information comme pour la premiere rangée crée.
Puisque toutes les balles vont être identiques, nous pouvons employer cette méthode pour définir cinq balles avec moins de code que si nous devions le faire un par un. Cette boucle créera les éléments BulletInfo[1], BulletInfo[2], BulletInfo[3], BulletInfo[4], et BulletInfo[5].
À l'intérieur de chaque élément dans BulletInfo, il y a cinq types différents.
D'abord, nous chargeont l'image à employer pour la balle, et nous la stockons dans la variable "pic".
Puis, nous avons une "firing" qui indiquera si cette balle est mise à feu à l'heure actuelle.
Il y a "Direction" qui mémorise la direction de la balle.
Ensuite, nous avons "X", ça placera la balle à la position X du joueur en ajoutant 32 Pixel de sorte que la balle sorte du bord du joueur.
Pour finir, nous avons "Y", ça placera la balle à la position Y du joueur en ajoutant 16 Pixel de sorte que la balle sorte du centre du joueur.

Regardons la prochaine section de code. Nous créerons une fonction appelée "bulletSetup()" qui mémorisera toute les informations que nous devons avoir. Cette fonction se lancera plus tard à chaque fois que le bouton "X" sera préssé. Cette fonction créera une balle à la position que l'on a défini plus haut.
Regardez le code, je le détaillerai plus bas :

--Functions

function bulletSetup()
--Increase the current bullet by one, or reset it to 1
if currentBullet < 5 then
currentBullet = currentBullet + 1
else
currentBullet = 1
end
if direction == "left" then
BulletInfo[currentBullet].x = Player[1].x
BulletInfo[currentBullet].y = Player[1].y + 16
end
if direction == "right" then
BulletInfo[currentBullet].x = Player[1].x + 32
BulletInfo[currentBullet].y = Player[1].y + 16
end
if direction == "up" then
BulletInfo[currentBullet].x = Player[1].x + 16
BulletInfo[currentBullet].y = Player[1].y
end
if direction == "down" then
BulletInfo[currentBullet].x = Player[1].x + 16
BulletInfo[currentBullet].y = Player[1].y + 32
end

BulletInfo[currentBullet].direction = direction
BulletInfo[currentBullet].firing = true
end

La première partie de la fonction commence par "if currentBullet < 5 then". Ce morceau de code indique que si la variable "currentBullet" est inferieur à 5, alors la variable "currentBullet" augmente de 1. Si cette variable est inferieur à 5, alors la variable se règle sur 1. Chaque fois que nous tirons une balle, ce code créera une nouvelle balle à la place de la précédente, de sorte que la dernière balle tirée puisse encore être sur l'écran.
La prochaine partie de code a quatre contrôles de direction. Ces contrôles placeront les nouvelles balles sur le perso selon sa position.
Sans ça, notre balle se créérai toujours sur la même face du personnage et il ne nous serai donc pas possible de tourner pour tirer.
Nous utilisons la variable "currentBullet" pour dire au programme quel élément de BulletInfo doit être utilisé.
La section de code "BulletInfo[currentBullet].direction = direction" place la direction de la balle dans la direction du joueur.La balle gardera cette direction jusqu'à ce qu'elle n'existe plus. La direction de la balle ne changera pas, même si le joueur change de direction.
La derniere section de code nous informe par "true" (vrai) qu'une balle a etait tiré (en haut à gauche ).

Ensuite, nous créons une autre fonction. Cette fonction vérifira si une balle a était tiré, et si oui, elle apparaitra à l'écran.
Jetez-y un coup d'oeil :

function bulletFire()
for i = 1,5 do
if BulletInfo[i].firing == true then
if BulletInfo[i].direction == "right" then BulletInfo[i].x = BulletInfo[i].x + 10 end
if BulletInfo[i].direction == "left" then BulletInfo[i].x = BulletInfo[i].x - 10 end
if BulletInfo[i].direction == "up" then BulletInfo[i].y = BulletInfo[i].y - 10 end
if BulletInfo[i].direction == "down" then BulletInfo[i].y = BulletInfo[i].y + 10 end
screen:blit(BulletInfo[i].x,BulletInfo[i].y,BulletInfo[i].pic)
end
if BulletInfo[i].x < 0 or BulletInfo[i].x > 480 or BulletInfo[i].y < 0 or BulletInfo[i].y > 272 then BulletInfo[i].firing = false end
end
end

Cette partie de code vérifiera les éléments de BulletInfo 1 à 5 et regarder si la "mise à feu" est en cour.
Si le tir est en cour, alors ça vérifie dans quelle direction la balle est tirée. Quand la direction sera trouvée, la position de la balle sera augmentéé de 10 Pixel dans la direction dans laquel elle a était tirée.
La gauche et la droite ne changeront qu'en "x" , et haut et bas seulement en "y".
Une fois que toute ces informations sont traitée, les balles s'afficheront à l'écran dans la position exact du tir effectué.
Après ça, nous avons un code pour vérifier si la balle est encore à l'écran ou pas.
-Si la position en "x" est inférieur à 0 alors la balle est en dehors de l'écran (vers la gauche).
-Si la position en "x" est supérieur à 480 alors la balle est en dehors de l'écran (vers la droite).
-Si la position en "y" est inférieur à 0 alors la balle est en dehors de l'écran (vers le haut).
-Si la position en "y" est supérieur à 272 alors la balle est en dehors de l'écran (vers le bas).
S'il détermine que la balle est en dehors de l'écran, alors ça placera l'état de la balle en "false" (faux).

Pour le prochain morceau de code, je n'entrerai pas dans les détails. Cette fonction détectera dans quel direction notre perso
se situera et l'indiquera en haut à gauche :

function movePlayer()
pad = Controls.read()
if pad:left() then
Player[1].x = Player[1].x - 1
direction = "left"
end
if pad:right() then
Player[1].x = Player[1].x + 1
direction = "right"
end
if pad:up() then
Player[1].y = Player[1].y - 1
direction = "up"
end
if pad:down() then
Player[1].y = Player[1].y + 1
direction = "down"
end
end

Maintenant nous créons notre boucle principale :

--Main Loop
while true do
pad = Controls.read()
screen:clear()

screen:blit(Player[1].x, Player[1].y, player)

if pad:cross() and oldpad:cross() ~= pad:cross() then
bulletSetup()
end

Voici le commencement de notre boucle. D'abord, nos commandes sont installées. Ensuite, le code pour afficher notre perso à l'écran.
La ligne suivante commence par une instruction "if". Cette ligne signifie que si (if) la touche "X" est enfoncée, alors ça executera
la fonction "bulletSetup()". La partie "oldpad" s'éxecutera seulement si le bouton a etait laché et encore préssé depuis la dernière fois où il a été exécutée.

Pour le prochain morceau de code, nous imprimerons lesinformations à l'écran de sorte que vous puissiez voir ce qui se passe quand vous exécutez le programme.
Nous imprimerons à l'écran les éléments de la mise à feu des balles (BulletInfo) de 1 à 5. Ca nous indiquerales quelles de ces balles ont été mise à feu.
"tostring" convertit les informations en string (= chaine de caractere) comme ça, nous pourrons imprimer les info à l'écran.
Nous imprimons également la direction du joueur à l'écran :

--Print bullet info to screen.
screen:print(10,10,"Bullet 1: ".. tostring(BulletInfo[1].firing),green)
screen:print(10,20,"Bullet 2: "..tostring(BulletInfo[2].firing),green)
screen:print(10,30,"Bullet 3: "..tostring(BulletInfo[3].firing),green)
screen:print(10,40,"Bullet 4: "..tostring(BulletInfo[4].firing),green)
screen:print(10,50,"Bullet 5: "..tostring(BulletInfo[5].firing),green)
screen:print(10,60,"Direction: "..direction,green)

Nous allons maintenant boucler notre programme :

movePlayer()

bulletFire()

screen.waitVblankStart()
screen.flip()
oldpad = pad
end

La fonction movePlayer() s'appelle pour assurer le mouvement du joueur à chaque boucle.
Tandis que la fonction bulletFire() s'appelle à chaque boucle pour afficher des balles sur l'écran si une balle a été tirée.

Le petit programme que nous allons développer tout au long de se cour affichera un minuteur à l'écran.
Le message qui s'affichera dépendra du temp écouler pendant une période définit.

Commençons par créer une couleur que l'on utilisera plus tard :

white = Color.new(255,255,255)

Pour pouvoir créer un minuteur, nous aurons besoin de la commande Timer.new().
Nous stockons ce minuteur dans une variable. Créons dès à présent le minuteur :

minuteur = Timer.new()

Afin de débuter ou d'arrêter le minuteur, nous devons utiliser les commandes "nomtimer:start()" et "nomtimer:stop()", nous voulons lancer le minuteur au début de ce programme donc, ajoutez ce code :

minuteur:start()

Notez que nous avons employé le nom de notre minuteur dans la commande. Ensuite, nous voulons créer notre boucle principale, ajoutons ce code pour éffacer l'écran à chaque boucle :

while true do
screen:clear()

Maintenant, dans notre programme, nous devons suivre le compte à rebour du compteur en direct.
Pour se faire, nous emploirons la commande "nomminuteur:time()". Faites comme ceci :

currentTime = minuteur:time()

Ce code stockera le compte à rebour du compteur dans la variable currentTime.

Ensuite, nous ajouterons un code pour imprimer le compte à rebour du compteur à l'écran à chaque boucle.
Ajoutez se code :

screen:print(10,10,"Compte a Rebour: " .. currentTime,blanc)

Analysez se code :

if currentTime < 1000 then
screen:print(100,100,"Plus petit que 1000",blanc)
end

Ce code vérifiera si le temps du compteurr est inférieur à 1000. Si oui, alors "plus petit que 1000" sera imprimé à l'écran.

Voici la suite du code :

if currentTime > 1000 and currentTime < 2000 then
screen:print(100,100,"Plus grand que 1000",blanc)
end

Ce code vérifiera si le temps du compteurr est supérieur à 1000 mais inférieur à 2000. Si oui, alors "plus grand que 1000" sera imprimé à l'écran.

La fin de la premiere ligne signifie que si le compteur dépasse 2000, alors celui-ci sera remit à zéro.
Nous pouvons aussi remettre à zéro le compteur avec la commande timername:reset(nombre).
Le nom entre les parenthèse est le nombre ou le compte à rebour se remet après avoir dépasser 2000. Remettre à zéro
le compteur l'arrete par la même occasion, nous devrons donc le remttre en marche. Examinez le prochain code :

if currentTime > 2000 then
minuteur:reset(0)
minuteur:start()
end

Avec se code, si le compteur dépasse 2000, il est remit à zéro et se relance tout de suite.
Enfin, nous pouvons fermer notre boucle :

screen.waitVblankStart()
screen.flip()
end

Dans se cours, nous allons apprendre à créer et utiliser des tables .

Bon, commencons par le début: qu'est ce qu'une table?
Pour faire simple, c'est comme une variable où l'on peut stocker plusieurs informations.
On en a déja utilisée dans d'autres tuto, et comme l'utilisation de table est plus qu'importante en programmation, on va consacrer ce tuto à comprendre
son fonctionnement.

Nous allons créer un petit programme ou il y aura 5 types d'ennemis et 2 joueurs ensuite nous allons renseigner le programme en lui donnant des infos sur les personnages. Je suis sur que vous débordez d'idées mais bon, ici nous allons nous contenter de faire simple : nous allons avoir 4 ennemis différents à tuer avec chacun une jauge de vie différente.

En 1er, nous allons donner au programme les informations sur la vie des ennemis nous devons aussi identifier quel type d'ennemis nous affrontons pour notre joueur, il faut aussi définir une jauge de vie et un type d'arme c'est ce que nous allons faire maintenat:

On va commencer par créer une table:

"tablename={}" est la syntaxe pour créer une table, on peut choisir le nom que l'on veut pour remplacer tablename. Nous créons donc une table vide sans
données.
Pour remplir la table de données, il faut utiliser la syntaxe suivante:
"myTable={12,14,16,18,20}" en séparant chaque donnée avec une "virgule".
Il faut garder a l'esprit qu'une table fonctionne exactement comme une variable en très légèrement plus compliqué.

Bien! voyons comment accéder aux données de la table:
"luckyNumber=myTable[1]". comme vous venez de le comprendre pour accéder à un élément d'une table, il suffit d'écrire le nom de la table avec l'emplacement
de la donnée entre [ ]. compliqué? pas vraiment....

Bon maintenant vous commencez à savoir utiliser une table.

Il existe une 2eme méthode pour remplir une table, elle se présente sous la forme suivante :

myTable={}
myTable[1]="pomme"
myTable[2]="orange"
myTable[3]="banane"

Cette méthode permet d'rajouter des éléments à l'interieur d'une table déja créée .

Jusque la, on peut se demander quelle est l'intéret d'utiliser une table plutot qu'une série de variable. voici l'avantage d'une table:
On peut associer plusieurs caractéristiques à chaque éléments de la variable ca sera plus clair avec un petit programme:

robe={}
robe[1]={color="blue",size="small"}

robe[1].color
robe[1].size

On utilise nos données en utilisant la syntaxe ci-dessus .

On pourrait comparer cela à l'utilisation d'un tableau avec des lignes (ca s'est les variables de "base") et des colonnes (ca s'est nouveau)ce qui permet le stockage d'un plus grand nombre de données en facilitant la lecture de ces données .

Maintenant qu'on a compris les avantages des tables, revenons a notre programme.

Nous allons donc créer une table pour stocker les informations conernant nos ennemis :

green=Color.new(0,255,0)

Enemy={}
Enemy[1]={type="gargoyle",health=100}
Enemy[2]={type="vampire",health=120}
Enemy[3]={type="goomba",health=140}
Enemy[4]={type="ghost",health=160}
Enemy[5]={type="zombie",health=180}

Bon, maintenant créons nos 2 joueurs:

Player={}
Player[1]={weapon="sword",health=200}
Player[2]={weapon="knife",health=100}

On a maintenant tout ce qu'il nous faut pour notre example, notez que le but n'est pas de réaliser un jeu complet avec un joueur et ses mouvements mais l'utilisation de table est vraiment bien pratique pour réaliserce genre de chose.
Dans ce tuto nous allons nous contenter d'afficher les informations sur le
joueur 1 (le joueur 2 servira dans un autre tuto)et sur les ennemis et nous diminuerons la vie de l'ennemi en appuyant sur "X"

Bien, on va créer la boucle principale:

while true do
pad=Controls.read()

ensuite on va "nettoyer" l'écran à chaque début de boucle :


screen:clear()

puis afficher les infos du joueur 1 :

screen:print(5,10,"Player 1 Health: " .. Player[1].health,green)
screen:print(5,20,"Player 1 Weapon: " .. Player[1].weapon,green)

Un petit rappel pour les étourdis qui ne comprendraient pas les 2 lignes ci dessus:
screen:print() --> permet l'affichage
5 -->est la coordonné sur x
10 --> est la coordonné sur y
"Player 1 health:" --> le texte à afficher
"..Player[1].health" --> correspond à l'emplacement de stockage de la vie du joueur.
green --> est la couleur d'affichage définie au début du programme.

Ensuite on va afficher les infos concernant les ennemis :

screen:print(250,10,"Enemy Health: " .. Enemy[1].health,green)
screen:print(250,20,"Enemy Type: " .. Enemy[1].type,green)

Ensuite on va rajouter la détection de la touche "X" ainsi que son effet :

if pad:cross() then
Enemy[1].health = Enemy[1].health - 5
end

Et enfin, on va terminer la boucle principale:

screen.waitVblankStart()
screen.flip()
end

On teste tout ca???????Hein quoi ca va pas???Bah oui, la vie de l'ennemi fond à vue d'oeil puis passe même en négatif!!!! C'est normal, nous allons résoudre ça.
Sous la ligne où on a défini la couleur, on va rajouter cette ligne:

oldpad = Controls.read()
elle permet d'éviter la chute trop rapide de la vie en faisant en sorte que l'appui sur la touche "X" ne soit détecté qu'une seule fois par pression en étant combiné à cette ligne:

if pad:cross() and oldpad:cross() ~= pad:cross() then

Qui va remplacer la ligne suivante:

if pad:cross() then

Enfin, on rajoute la ligne oldpad = pad juste avant le end final
On réessaye le tout pour voir ce que ca donne!!!!!!!!!
alors c'est mieux???? Ah oui il reste encore un petit truc....
La vie de l'ennemi passe toujours en négatif!!!!!

Bon bah on va modifier cette ligne:

if pad:cross() and oldpad:cross() ~= pad:cross() then

Pour rajouter une condition qui empechera la vie de passer en négatif, nous allons donc la remplacer par cette ligne-ci:

if pad:cross() and oldpad:cross() ~= pad:cross() and Enemy[1].health > 0 then

Et voila!!!!!
Tout fonctionne!!!!!

Dans ce turorial, nous allons apprendre comment utiliser et créer ses propres fonctions.
créer ses fonctions revient à créer ses propres commandes en lua. cela peut permettre
d'éviter des portions de code répétitives.... on crée une fois la fonction et hop!!!
plus qu'une ligne à taper dans la boucle principale!!!!!!!

La bonne idée consiste donc à créer ses fonctions avant le début de la boucle pour s'en servir dans la boucle principale

Bon commencons par voir comment se présente une fonction:

function functionname()
--(le codage même de la fonction peut s'étaler sur plusieurs lignes)
end

Bon bah, ca a pas l'air si compliqué que ca???
Aller hop, un exemple:

function printMessage()
screen:print(100,100,"functions are fun")
end

Maintenant, dès que l'on tapera "printMessage()" dans le code, cela affichera "functions are fun".
Vous voyez!!!!! c'est très simple.

On peut aussi se servir des fonctions pour créer une opération, exemple :

function additUp(a,b)
sum=a+b
return sum
end

Explication: notez qu'entre parenthèse nous avons placé des lettres, mais on aurait aussi bien pu mettre des variables, des chiffres ou ce que l'on veut.
On peut placer autant de variable que l'on souhaite, il suffit juste de les séparer par des virgules dans cette function, nous avons créer une variable "sum" qui correspond au résultat
de l'addition de "a" et de "b".
La commande return permet de renvoyer la variable "sum" lorsque l'on appelle la fonction, en bref lorsque dans le boucle on tapera "additUp(a,b)" on aura comme le résultat de
l'addition qui sera stocké dans "sum".

Maintenant voyons un peu ce qu'on peut en faire de cette fonction :

screen:print(100,100,additUp(5,6),green

Cette ligne affichera directement le résultat de l'opération 5+6

myTotal=additUp(5,6)

Le résultat sera stocké dans myTotal.

Bon, passons à un exemple concret en observant ce programme :

grass = Image.load("grass.png")
player = Image.load("player.png")
flower = Image.load("flower.png")

screenwidth = 480 - player:width()
screenheight = 272 - player:width()

Player = { }
Player[1] = { x = 200, y = 50 }

while true do
pad = Controls.read()
screen:clear()

for a = 0, 14 do
for b = 0,8 do
screen:blit(32 * a, 32 * b, grass)
end
end

screen:blit(100,100,flower)
screen:blit(300,220,flower)

screen:blit(Player[1].x,Player[1].y,player)

if pad:left() and Player[1].x > 0 then
Player[1].x = Player[1].x - 2
end

if pad:right() and Player[1].x < screenwidth then
Player[1].x = Player[1].x + 2
end

if pad:up() and Player[1].y > 0 then
Player[1].y = Player[1].y - 2
end

if pad:down() and Player[1].y < screenheight then
Player[1].y = Player[1].y + 2
end

screen.waitVblankStart()
screen.flip()
end

On peut voir que la boucle principale est assez grande et remplie de lignes de codes.
Nous allons donc vous montrer comment la simplifiiée en utilisant les fonctions :

grass = Image.load("grass.png")
player = Image.load("player.png")
flower = Image.load("flower.png")

screenwidth = 480 - player:width()
screenheight = 272 - player:width()

Player = { }
Player[1] = { x = 200, y = 50 }

-- Function to check player movements
function playerMovement()
pad = Controls.read()
if pad:left() and Player[1].x > 0 then
Player[1].x = Player[1].x - 2
end

if pad:right() and Player[1].x < screenwidth then
Player[1].x = Player[1].x + 2
end

if pad:up() and Player[1].y > 0 then
Player[1].y = Player[1].y - 2
end

if pad:down() and Player[1].y < screenheight then
Player[1].y = Player[1].y + 2
end
end

-- Function to paste images to screen
function pasteImages()
for a = 0, 14 do
for b = 0,8 do
screen:blit(32 * a, 32 * b, grass)
end
end

screen:blit(100,100,flower)
screen:blit(300,220,flower)

screen:blit(Player[1].x,Player[1].y,player)
end

-- Boucle prinsipale
while true do

screen:clear()

pasteImages()

playerMovement()

screen.waitVblankStart()
screen.flip()
end

Alors, vous voyez la différence????
La boucle principale ne fait plus que quelques lignes!!!!!
Ce qui en facilite grandement la lecture.....

Ce tutorial est désormais terminé. j'espère qu'il vous sera utile.

Ce cours va vous apprendre à incruster des sons/musiques à vos projets en LUA.

Tout dabord, sachez que LUAplayer supporte ces formats de sons différents: UNI, IT, XM, S3M, MOD, MTM, STM, DSM, MED, FAR, ULT et 669 pour la musique.
Des dossier WAV peuvent être utilisés pour les sons. Il est possible des convertir les fichiers MIDI dans tout les formats cités plus haut.
Utilisez par exemple Modplug Tracker pour vos conversions. Mettez vous simplement que LUA NE SUPPORTE PAS les fichier MP3.

Regardez la premiere commande. Celle-ci permet de jouer la musique voulu :

Music.playFile(string file, bool loop)

Donc, la ou est situé "string file", vous placerez le nom du dossier et le nom de la musique que vous voulez charger avec l'extension à la fin (exemple : musique.xm).
Pour "bool loop", vous mettrez ou "true" ou "false". "True" jouera la musique en boucle et "false" ne jouera la musique qu'une seul fois.
Voici un exemple :

Music.playFile("mysong.mod", true)

Regardez la suite. Ce qui suit peut être employé après que vous ayez lancez votre musique :

Music.pause()
Music.stop()
Music.resume()

Voici quelques explications :
Music.pause() mettra en pause votre chanson.
Music.stop() arrêtera votre chanson.
Music.resume() reprendra votre chanson si vous l'avez temporairement arrêtée.

Il existe également une commande que nous pouvons utilisé pour vérifier qu'une chanson se joue ou pas. Cette commande renverra vrai ou faux.
Jetez un coup d'oeil :

Music.playing()

En gros, ça examine si notre chanson se joue, et si c'est le cas, alors imprimer un message à l'écran.
Un exemple :

if Music.playing() == true then
screen:print(10,10,"Music is playing",white)
end

Vous pouvez également regler le volume de votre musique avec cette commande. Dans les parenthèses placez simplement un nombre de 0 à 128 :

Music.volume(Number)

Maintenant, nous allons aborder le sujet des sons, en particuliers les sons au format WAV. Pour les chargez, se n'est pas pareil que pour les musiques, voici la commande :

bonkSound = Sound.load("bonk.wav",false)

Le fichier wav est chargé dans une variable (bonkSound) que nous utiliserons plus tard pour lancer se son . Nous avons utilisé "false" de sorte que le son ne fasse pas une boucle.
Si vous voulez que le son se répete indéfiniment, utilisez "true" (c'est pareil que pour les musiques ).
Quelque chose de très importante au sujet des fichiers WAV, c'est qu'ils doivent être mono et non stéréo. Vous pouvez vérifier ceci par un clique droit sur le fichier, "propriétés", et l'info se trouve dans "résumé".

Voyons maintenant quelques commandes supplémentaires. La prochaine commande jouera le fichier. Utilisez le nom de la variable que nous avons définit plus haut. Comme ceci :

bonkSound:play()

Cependant, je ne vous recommande pas d'tiliser cette méthode pour jouer le fichier. Cette méthode peu amener à une erreur.
Voila se que je vous ocnseil de faire. La seule chose que vous devriez changer de ce code est le "bonkSound" si vous utilisez une variable différente :

local sound = bonkSound
voice = sound:play()

Pour arreter le son :

voice:stop()

Nous pouvons également utiliser une commande comme nous l'avons fait pour la musique, pour voir si le son se joue. Voici la commande :

voice:playing()

Il y a d'autres commandes pour le sons et la musique que vous pouvez découvrir ci-apres, mais ce que nous avons déjà vue tout au long du cour devrez vous suffir pour utiliser a bien vos sons/musiques .

Nous allons créer un petit programme pour appliquer se que nous avons vu. Le programme débutera sur le choix d'un fond d'écran bleu ou noir.
Quand "X" sera presser, le programme passera a la prochaine partie avec la couleur du background voulu. Dans cette même partie, le programme écrira combien de fois le programme a été exécutées.
Comment ? C'est simple, chaque fois que nous appuirons sur "X" sur l'écran menu, le programme ouvrira un fichier (que nous allons créer), et enregistrera les données voulu.
Le programme lira également le nombre à partir du fichier et le stockera dans une variable. Si vous quittez complètement le programme et revenez dessus plus tard, il vous montrera toujours combien de fois il a été executés, puisqu'il est stocké dans un fichier.
Commençons.

En premier, créez un fichier txt normal (avec notpad ou un editeur de texte ordinaire ). Dedans, placez-y le chiffre "0" et enregistrez le sous le nom "counter.txt".

Commençons maintenant le programme en lui même. Créons les couleurs avant tout (plus besoin de vous expliquer se passage ) :

blanc = Color.new(255,255,255)
bleu = Color.new(0,0,255)
noir = Color.new(0,0,0)

Ensuite, quelques variables :

oldpad = Controls.read()
startcolor = noir
gamestate = "menu"

-oldpad : stockera les infos du dernier bouton pressé.
-startcolor : stockera la couleur que nous emploierons pour commencer la deuxième moitié du programme plus tard.
-Gamestate : servira à savoir quel fonction nous devons utiliser. Nous crérons deux fonctions. Une pour lancer le menu et l'autre lancera le reste de notre programme.

Notre prochaine partie de programme va traiter les sons!. Vous pouvez téléchargez les deux petits fichiers WAV qui vont nous servir dans cette application en fin de cours, vous les placerez à coter de votre programme.

Nous ne voulons pas que les sons se reproduisent indéfinimement, nous plaçons donc le deuxieme argument de ces fonction à "false" :

menusound = Sound.load("beep.wav",false)
goodbye = Sound.load("goodbye.wav",false)

A ce moment du programme, nous ouvrirons notre fichier counter.txt créé plus tot et la valeur qui s'y trouve sera lu et mit dans la variable "counter".

file = io.open("counter.txt", "r")
counter = file:read("*n")
file:close()

Note : nous utilisons "*n" pour lire un nombre dans le fichier.

Maintenant, nous allons créer notre selectionneur, il servira à selectionner un des deux choix dans le menu. Il sera fait à partir d'une image et aura la couleur bleu :

selector = { image = Image.createEmpty(210,15), x = 147,y = 77 }
selector.image:clear(blue)

Nous créons maintenant une fonction drawMenu() qui exécutera tout le code nécessaire pour charger le menu :

function drawMenu()

Nous utiliserons cette fonction comme une fonction faisant une boucle ainsi chaque boucle nous nettoie l'écran et lit les commandes :

screen:clear()
pad = Controls.read()

Ensuite, nous allons imprimer à l'ecran le selectionneur (en bleu) et quelques lignes avec:

screen:blit(selector.x,selector.y,selector.image)
screen:print(150,80,"Lancer le programme (Noir)",blanc)
screen:print(150,100,"Lancer le programme (Bleu)",blanc)

Notez que nous utilisons les valeurs du selectionneur(x et y ) pour l'imprimer à l'ecran. Cette image du sélecteur se déplacera de haut en bas suivant le choix que l'on fera.
Nous voulons être sûrs que le selectionneur soit imprimé à l'écran avant d'imprimer le texte ou qu'il se mette sous le texte.

Nos deux lignes de texte imprimées seront nos deux options du programme. Commencez le jeu avec un écran noir ou un écran bleu.

Les lignes de code à venir à l'intérieur de la fonction vérifieront la pression des boutons. Faisons la fleche de haut en premier :

if pad:up() and oldpad:up() ~= pad:up() then
selector.y = 77
startcolor = noir
local sound = menusound
voice = sound:play()
end

La premiere ligne indique que si la fleche du haut et presser et que si la touche haut n'est pas la derniere à avoir été presser, alors ...
La seconde ligne place la valeur en Y du selectionneur à 77.
La troisième ligne indique la couleur de départ (le noir) du fond d'écran.
Les dernieres lignes joue le morceau wav en utilisant la méthode que je vous ai recommandé plus haut.

Maintenant, nous allons faire pareil pour la fleche bas, c'est la même chose que pour la fleche du haut mais avec la couleur de départ en bleu :

if pad:down() and oldpad:down() ~= pad:down() then
selector.y = 97
startcolor = bleu
local sound = menusound
voice = sound:play()
end

Maintenant, nous allons faire la touche "X" :

if pad:cross() and oldpad:cross() ~= pad:cross() then
gamestate = "game"
counter = counter + 1
file = io.open("counter.txt","w")
file:write(counter)
file:close()
end
end

Nous plaçons le "gamestate" en "game" pour que le code du menu ne sera plus executer (pour ne pas prendre de la memoire des que l'on est plus sur le menu ).
Nous ajoutons à notre variable "counter", +1.
Ensuite, le fichier "counter.txt" est ouvert et écrit la nouvel valeur, remplaçant l'ancienne valeur.
N'oubliez pas de fermer votre fichier.
Nous cloturons la fonction par un "end". Voila, la fonction drawMenu() est faites.

Notre prochaine fonction exécutera le reste du jeu après que nous ayons "quitter" le menu. Cette fonction est plutôt petite et simple, tellement que la voila entière :

function playGame()
screen:clear(startcolor)
pad = Controls.read()

screen:print(100,100,"This program has been executed " .. counter .. " times.",blanc)
screen:print(100,110,"Press Start to exit to Menu",blanc)

if pad:start() then
gamestate = "menu"
local sound = goodbye
voice = sound:play()
end
end

Dans cette fonction, nous affichons à l'écran la couleur que vous avec choisi dans le menu en utilisant la variable startcolor.
Deux messages sont imprimés, et un contrôle pour le bouton start. Ceci placera le gamestate de nouveau au menu si start est préssé, et jouera un fichier wav en même temps.

Après nous commençons notre boucle principale de programme. C'est grâce très courte et facile à nos fonctions.
Dans cette boucle, nous vérifierons dans quel état le jeu est et ça exécutera la fonction suivant l'état :

while true do

if gamestate == "menu" then
drawMenu()
end

if gamestate == "game" then
playGame()
end

screen.flip()
oldpad = pad
end