Archives pour l'étiquette nspire

L’OS 3.2 pour TI-Nspire est arrivé !

Salut à tous,

Bonnes nouvelles pour les programmeurs Lua Nspire, TI mis à jour le système d’exploitation Nspire en version 3.2, qui est une grande mise à jour pour la programmation Lua!

En effet, il apporte, en outre de quelques modifications de l’API, 2 choses principales:

– Un SDK intégré (Software Development Kit) pour le Logiciel Npire, qui vous permet de programmer en Lua directement dans le logiciel. Il dispose d’une certaine auto-complétion, coloration syntaxique, un débogueur, etc 🙂

Screenshot of the 3.2 Lua Script Editor
Lua Script Editor

– Un moteur physique … Oui! Vous allez maintenant être en mesure de créer des simulations et des jeux basées sur de la physique, sans avoir à tout coder à partir de zéro!

Nous vous encourageons à consulter le Wiki (nous sommes en train d’y détailler les nouvelles fonctions) qui dispose d’une page qui résume tous les changements de l’API en version 3.2, ainsi que la documentation officielle de TI.

« Have fun » !

Démarrer en Lua sur Nspire

Bonjour et bienvenue sur la page d’accueil des tutoriaux !

Vous avez plusieurs possibilités pour apprendre la programmation Lua sur TI-Nspire.

Inspired-Lua contient un certain nombre de tutoriaux, mais pointe aussi vers d’autres sites (comme celui de Steve Arnold).

Voici quelques liens utiles :

Nous vous conseillons de commencer… par le début, et pour cela, veuillez suivre ce lien pour des tutoriaux de A-à-Z.

Ce lien pointe vers une page où sont rédigées toute une série d’excellents tutoriaux mais en Anglais. Inspired-Lua a commencé à en traduire en Français (voir le lien quelques lignes plus tard sur les tutoriaux de « pratique »)

Si vous voulez vous plonger dans les tutoriaux théoriques sur la programmation Nspire Lua, clique ici !

Sinon, si vous voulez directement commencer par des tutoriaux de pratique, en apprenant par l’exemple, c’est par là que ça se passe.

 

Bonne programmation Lua sur TI-Nspire !

Comment avoir une petite fonction « input » bien sympa en Lua…

(improved version of Nick Steen’s website’s example)

Vous pourriez être très surpris par le fait qu’il n’y ait pas de manière native d’avoir une fonction d’entrée clavier (input) texte sur l’API Lua Nspire. En effet, c’est un peu bizarre car ce sont souvent utilisés pour de nombreux types de programmes (que ce soit dans les jeux pour taper le nom d’utilisateur, ou d’autres applications pour entrer des données utilisateur, etc.)

Quoi qu’il en soit, ne vous inquiétez pas, vous pouvez le programmer vous-même avec un petit bout de code à ajouter à votre script! Il capture en fait les touches appuyées avec la fonction on.charIn , et les enregistre ce que l’utilisateur tape dans une chaîne (concaténation). Il suffit ensuite d’afficher cette chaîne à l’écran, et c’est tout !

Si vous voulez que l’utilisateur sera en mesure de supprimer quelques lettres, il suffit d’ajouter du code pour la fonction on.backspaceKey, et c’est tout!

Dans l’exemple ci-dessous, nous avons fixé une limite de caractères à 25, mais vous pouvez ajuster cette valeur vous-même.

Bref, voilà le code dans sa totalité :

input = ""   
 
function on.paint(gc)
    gc:drawString(input,5,5,"top")  -- display string
end
 
function on.charIn(char)
    if string.len(input) <= 25 then   -- limit of 25 chars
        input = input..char   -- concatenate
        platform.window:invalidate()   --screen refreh
    end
end
 
function on.backspaceKey()
    input = string.usub(input,0,-2)  -- deleting last char
    platform.window:invalidate()  
end

Fin du concours Nspire Lua

Bonjour à tous et à toutes,

Il y a quelques temps déjà, nous vous annoncions un concours de programmation sur Nspire en Lua à grande échelle puisque la somme totale des lots s’estimait environ à 750 € , avec notamment 3 magnifiques TI-Nspire CX CAS à gagner !

Le concours est désormais terminé !

C’est avec donc pas moins de 14 programmes Lua que nous avons terminé ce concours, et nous pensons que c’est une belle réussite pour un langage si « nouveau » sur cette calculatrice !

Nous tenons donc à remercier vivement tous les participants, quels que soient leurs résultats !

Les juges (Levak, Critor et moi-même) allons procéder à l’analyse de tout ce que vous nous avez fait, dans les prochains jours, et les résultats devraient être là prochainement :)

En attendant, voici la liste (juste Nom + Screenshot) des participations reçues.
(certains ne sont pas disponibles en téléchargement pour le moment, mais celà ne saurait tarder….)

Nous rappelons que ces programmes, sauf mention contraire sur la page de téléchargement, sont soumis à la licence CC BY-SA 2.0. Ne pas respecter les termes de cette licence entraînera des conséquences légales. Les auteurs des programmes respectifs peuvent changer cette attribution à leur souhait en nous contactant par e-mail, bien évidemment.

Jeux: 7


Bobby Carrot – – – – Loïc P.

Image
Labyrinthe – – – – David L.


Reversi (Othello) – – – – Deep Thought.

Image
MasterMind – – – – Nick V.


TI-Cran – – – – Julien R.


Nspired Phoenix Lua – – – – Florent D.


Tactical Wars CX – – – – Rehn C.

Mathématiques: 4


TabVar 3 – – – – JayTe.


LuaCS – – – – Jonathan L.


LogoMagic – – – – Jim B.


ABA Logique – – – – Loulou54.

Physique-Chimie: 3


Planétarium – – – – Bastien V.

Image
FormulaOne – – – – Naji A.

Image
Formules de Chimie – – – – Paul J.

Bref, en attendant les résultats officiels de ce concours, testez ces programmes et faites-nous part de vos commentaires !

Encore une fois Bravo à tous, et que les meilleurs gagnent !

TabVar v3, l’ultime programme de tableau de variations !

Bonjour à tous,

Aujourd’hui est un grand jour !

En effet, pour les possesseurs de Nspire avec un OS >= 3, JayTe nous a concocté un programme combinant la simplicité du TI-Basic à la puissance de Lua, pour notre grand plaisir…
Je vous présente … TabVar 3 !
Oui, le fameux programme qui étudie toutes vos fonctions en profondeur et vous trace un magnifique tableau de variations !

« Ben ou mais ca existe, non ? », me direz-vous.
Certes. L’idée n’est pas nouvelle.
Chronologiquement, on a en effet eu celui d’Adriweb, le premier pour Nspire, et par la suite, TabVar v1 et v2, par JayTe, dont le moteur est basé à l’origine sur le programme d’Adriweb, mais le tout a été poussé bien plus loin en intégrant beaucoup plus de fonctions plus poussées d’analyse de fonctions.

Ce programme dépasse largement tous ses concurrents, et autres .tns pouvant espérer le rivaliser.

La grande particularité de cette version est que ce programme en exclusivité sur TIPlanet profite et exploite vraiment les fonctionnalités que propose l’OS 3 en intégrant un script dynamique Lua pour un affichage optimal du tableau de variations, qui devient pour le coup totalement graphique. Plus besoin d’astuces [foireuses] pour afficher correctement un tableau de variation digne de ce nom…

Nous n’allons pas vous faire plus attendre pour vous faire découvrir une copie d’écran de TabVar :
Image
et le détail des calculs préliminaires (clic pour l’image en grand) :
Image

A ce jour, vous ne trouverez pas plus fiable au niveau du moteur utilisé (même si rien n’est parfait, bien sûr ; les fonctions de grande complexité peuvent être incomplètement étudiées…)
Vous pouvez par exemple, tester des fonctions assez complexes, comme des polynomiales, rationelles, avec ou sans asymptote(s) et avec ou sans comportements étranges aux limites…
Bref, pour un lycéen (ou autre !), c’est plus que parfait :-)

Lien de téléchargement : http://tiplanet.org/forum/archives_voir.php?id=3751

Merci Qui ?
Merci JayTe !

N’oubliez-pas qu’à ce jour, c’est ce programme qui est de loin le plus fiable et le plus agréable à la lecture pour les études de fonctions..
Une petite capture d’écran pour marquer le coup ?
(Exemple de TabVar v3 contre un concurrent pour la même fonction f(x)=1/x)
Image
Hé oui, pour ne pas avoir une mauvaise note, ne faites pas confiance aux imitations !

TI-Planet, LE site de référence pour trouver tout ce dont vous avez besoin et ce dont vous rêvez!

Tableau d’avancement (Nspire Lua)

Décidément, nous vous gâtons.
Encore une exclusivité TI-Planet aujourd’hui !

Notre cher membre Adriweb, après avoir sorti son programme de tableau d’avancement pour TI-83+/84+, nous a programmé hier son équivalent Nspire ! C’est une grande première sur cette calculatrice, d’autant plus que celui-ci profite, comme TabVar 3, de la nouveauté principale qu’offre l’OS 3, le Lua.

Le document se compose en fait de deux parties :
-> Vous lancez le programme (Basic) avancement() et suivez les étapes pour donner les informations sur la réaction chimique à étudier.
-> Allez dans l’onglet suivant et admirez le tableau d’avancement tracé en détail et en couleur (Nspire CX uniquement) !

Un petit screenshot ?

Image

Ce programme est open-source et sous licence Creative Commons 2.0 BY-SA.

Lien du topic sur TIPlanet (téléchargement ….) : http://tiplanet.org/forum/viewtopic.php?f=43&t=8385

TI-Planet : le site qui crée des programmes intelligents !

Au passage, joyeux halloween ;-)

Grand Concours TI-Nspire Lua 2011

Le concours est mainteannt  terminé, merci à tous d’avoir participé !

 

Les sites Inspired-Lua et TI-Planet, en partenariat avec R. JARRETY (où vous pouvez commander des calculatrices à prix spéciaux TI-Planet), organisent un nouveau concours d’une ampleur encore jamais atteinte !

Tout d’abord, pour la première fois dans l’histoire de notre site, le concours franchit les frontières de l’hexagone et vous pouvez tous participer, quelque soit votre pays de résidence !

Ensuite, la dotation est absolument sans précédent: 3 TI-Nspire CX CAS, pour trois fois plus de chances de gagner!

Non, vous ne rêvez pas !

Il vous suffit donc de créer un programme Lua pour TI-Nspire, en rapport avec l’une des 3 catégories suivantes:

  • Mathématiques
  • Physique-Chimie
  • Jeux

Vous aurez donc besoin d’un OS ou logiciel Nspire 3.0 ou ultérieur.

La seule condition est que Votre programme soit utilisable pour un utilisateur francophone. Si votre programme affiche du texte, l’utilisation isolée de mots courants en langue étrangère est tolérée.

Pour participer, il vous suffit tout simplement d’envoyer un email à info @ tiplanet . org d’ici le 7 novembre 2011 à 23h59 GMT+2 (heure d’été française):

  • vos nom et prénoms
  • votre adresse complète
  • une adresse email valide
  • la catégorie choisie
  • une archive en fichier attaché

L’archive attachée devra contenir:

  • le programme au format ‘tns’
  • le code source
  • une description dans un fichier ‘lisezmoi.txt’
  • éventuellement, une documentation (format et contenu libres)

Vous ne pouvez soumettre qu’un seul programme pour le concours, et donc vous ne pouvez participer que dans une seule catégorie. Choisissez-la bien !

Toutefois, il vous est parfaitement possible de mettre à jour un programme déjà soumis ou même de changer de programme ou de catégorie en envoyant tout simplement un nouvel email de participation, puisque seul le dernier reçu sera pris en compte.

Bonne chance à tous!

Liens:

Règle Officielles
Inspired-Lua (documentation & Lua ressources)
TI-Planet (aide & échanges)
Générateur Lua, « Luna »
OS 3.0.2 pour TI-Nspire
OS 3.0.2 pour TI-Nspire CAS
OS 3.0.2 pour TI-Nspire CX
OS 3.0.2 pour TI-Nspire CX CAS
TI-Nspire 3.0.2 Software « student » pour PC (free for 30 days)
TI-Nspire 3.0.2 Software « student » pour Mac (free for 30 days)
TI-Nspire 3.0.2 Software « teacher » pour PC (free for 90 days)
TI-Nspire 3.0.2 Software « teacher » pour Mac (free for 90 days)

L’Essentiel pour bien comprendre

Cette partie va tenter de vous expliquer comment le Lua fonctionne concrètement dans l’OS et vous aider à comprendre ce que vous faites lorsque vous écrivez un script pour TI-Nspire. Toute connaissances préalable en Lua ou d’un quelconque langage évènementiel n’est pas inutile, mais pas nécessaire.

Le Lua est un langage script interprété, ce qui signifie que ce n’est pas aussi rapide que l’ASM/C mais que cela reste bien mieux que le TI-BASIC. Une bonne chose à noter, c’est que ce langage est en parfaite harmonie avec l’OS car lié par une structure évènementielle et un assez confortable environnement graphique (GC). Tout d’abord, nous devons comprendre comment tout cela fonctionne.

Le Lua est normalement un langage script séquentiel. Par exemple, quand on demande d’afficher une valeur avec la commande print(), on peut très facilement deviner dans le code quand est-ce que la commande sera lancée. Voici un code d’exemple :

a = 1
print(a)
a = a + 1
print(a)

En sortie :

1
2

Rien de très surprenant. Seulement, sur TI-Nspire, le Lua a une toute autre approche. On rencontre cette approche lorsqu’on programme avec des langages de haut niveau ou objet (tel que le C++/Qt4, C#, etc …). Dans ces langages, nous ne sommes pas maîtres de l’exécution de tel ou tel code. Oui, c’est étrange d’entendre dire ça, et pourtant c’est la vérité. Nous allons programmer dans un langage qui ne nous obéit pas ? En quelque sorte, oui.

Pas d’inquiétude ! Nous sommes là pour vous aider à ce passage difficile si c’est la première fois que vous le franchissez !

Tout d’abord, il faut vous placer de l’autre côté du miroir. Avant, vous étiez le patron, c’est à dire que vous ordonniez à la machine de vous calculer 1 + 1 et elle vous renvoyait fièrement 2. Maintenant, vous êtes un ouvrier. On vous donne l’autorisation de faire une tâche, vous dites comment faire à la machine. Concrètement, les « autorisations » sont des évènements. Vous avez le droit de faire ce que vous voulez, à moins que vous en ayez reçu l’autorisation. Voici un pseudo code qui montre que faire lorsque l’évènement « FaireLaCuisine » est appelé :

function FaireLaCuisine()
	organiserLaPaillasse()
	couperLesIngredients()
	assembler()
	chauffer()
	servir()
end

Vous comprenez bien que vous n’allez pas faire la cuisine une fois qu’on vous a embauché. Vous allez attendre que votre maître de maison vous en donne l’autorisation/l’ordre pour la faire ! Et bien c’est la même chose en Lua sur TI-Nspire. Tout est question d’évènements ! Dans notre exemple – en imaginant que FaireLaCuisine est un évènement de l’API – l’API appelle la fonction FaireLaCuisine si elle existe lorsque les conditions nécessaires sont réunies.

Donc, si on résume, tout code de notre part doit être mis dans des fonctions que la TI-Nspire va lancer. Mais comment savoir lesquelles ? Et bien c’est là que nous vous invitons à jeter un œil à cette liste des évènements. Lorsqu’un évènement est appelé, il lui est passé zéro ou plusieurs arguments que l’on peut réutiliser dans le corps de la fonction. Cela permet par exemple de savoir quelle touche est actuellement active, car lorsque l’évènement charIn() est appelé, on lui passe en plus une chaîne de caractère correspondant à cette touche. Par contre, lorsque l’évènement enterKey() est appelé, aucun argument n’est nécessaire, donc aucun n’est passé.

Avant, dans un langage quelconque n’étant pas évènementiel (BASIC, C, PHP, etc …), on programmait de cette manière :

-- Initialisation des constantes ici
...
 
k = 0
while k != 0 do
	k = getKey()
end
if k == 72 then
	-- quelque chose
end

Maintenant, cela ressemblera à ça :

-- Initialisation des constantes ici
...
 
function on.charIn(ch)
    if ch == "7" then
	-- quelque chose
    end
end

>> Partie 2

Utilisation d’une variable existante dans un classeur TI-Nspire

Retour à la partie 3

Cette partie vous montrera que le Lua est bel et bien en parfaite harmonie avec la TI-Nspire et son framework. Pour cela nous vous proposons d’étudier l’API var et les évènements qui en découlent.

Tout d’abord , créez un nouveau classeur TI-Nspire et définissez y une variable n, par exemple un curseur permettant d’en faire varier la valeur entre 0 et 10 ou directement dans la page de l’application calculs.

C’est cette variable que nous allons récupérer dans le script Lua !

Pour cela, créez un nouveau fichier Lua avec votre éditeur de texte préféré et nous allons commencer à le remplir.

L’API var permet de faire pleins de choses intéressantes et nous allons les étudier.

Tout d’abord, notre script doit savoir si la variable n change. Nous trouvons donc cette ligne :

 

-- On indique ici qu'il faut surveiller le contenu de la variable n
var.monitor("n")

Au passage, nous pouvons écrire une fonction récursive qui renverra la factorielle d’un nombre, rien que pour l’exemple :

function factorielle(n)
	if math.floor(n) < n or n < 0 then
		return ("Erreur")
	elseif n == 0 then
		return(1)
	else
		return(n * factorielle(n - 1))
	end
end

Maintenant, nous allons nous intéresser au couplage des évènements. Il nous faut deux évènements. D’abord celui pour dessiner à l’écran, c’est à dire on.paint(), mais également un évènement déclenché lorsque notre variable change. Cet évènement est on.varChange() et est lancé chaque fois qu’une variable appartenant à la liste des variables surveillées (avec var.monitor()) est modifiée.

function on.varChange(varlist)
	-- On provoque une reactualisation de la fenetre
	platform.window:invalidate()
end

Concrètement, dès qu’une variable surveillée change, on demande à ce que l’écran soit actualisé. Donc maintenant, il faut faire cette partie d’affichage en créant la fonction on.paint(). En effet, appeler platform.window:invalidate() marque l’écran comme « invalide », donc bon à être actualisé. Au prochain tour de boucle de processus, comme l’écran doit être actualisé, le framework de la TI-Nspire lancera la fonction on.paint()

function on.paint(gc)
	local wh, ww, n, x
	-- nombre de pixels (hauteur et largeur)
	wh = platform.window:height()
	ww = platform.window:width()
 
	-- affichage d'un trait de separation
	gc:setPen("medium", "smooth")
	gc:drawLine(0, 60, ww, 60)
 
	-- affichage de la taille de la fenetre en bas de l'ecran
	-- il s'agit juste d'un exemple !
	gc:setColorRGB(200, 200, 200)
	x = gc:drawString(wh, 10, wh - 10, "bottom")
	gc:drawString(ww, x + 10, wh - 10, "bottom")
 
	-- affichage de n!
	n = var.recall("n")
	if math.floor(n) < n or n < 0 then
		gc:setColorRGB(255, 0, 0)
		gc:setFont("sansserif" , "b", 10)
		gc:drawString("n n'est pas un ",10,10,"top")
		gc:drawString("entier naturel ",10,25,"top")
	else
		gc:setColorRGB(0, 0, 255)
		gc:setFont("sansserif" , "b", 20)
		x = gc:drawString(n.."! = ", 10, 10, "top")
		x = gc:drawString(factorielle(n), x + 5, 10, "top")
	end
end

Voilà ! C’est tout !

Lancez ensuite TI-Nspire Scripting tools et cliquez sur le premier bouton (ou choisissez tools, Lua Script to Clipboard) puis sélectionnez le fichier contenant le script que nous venons de créer. Allez dans le logiciel TI-Nspire, et utilisez Ctrl V pour copier le code Lua.

Faites ensuite varier la valeur de n, et la miracle !

La valeur dans la fenêtre Lua est actualisée !

Tip : Si vous avez modifié le script, il vous suffit dans TI-Nspire Scripting Tools de

  • cliquer sur le second bouton (ou choisissez tools, Reload Script).
  • Allez ensuite dans le logiciel TI-Nspire, cliquer sur la fenêtre correspondant au code Lua.
  • Ctrl K pour sélectionner cette fenêtre
  • Ctrl V pour copier le nouveau script Lua

Idées d’améliorations :

Vous pouvez tester une première « amélioration » de ce script en ajoutant les lignes suivantes, permettant de « piloter » n avec les touches « vers le haut » ou « vers le bas » :

function on.arrowUp()
	var.store("n", var.recall("n") + 1)
end
 
function on.arrowDown()
	var.store("n", var.recall("n") - 1)
end

>> Partie 5

Classes d’objets

Retour à la partie 4

Dans cette partie nous allons étudier une notion assez pratique du Lua, celle de manipuler non plus des variables, mais des objets.

Si vous avez déjà étudié le Lua auparavant, vous devriez savoir que c’est un langage utilisant excessivement les tables indexées par clés. Cela veut dire que chaque élément d’un tableau (ou liste) est associé à une clé qui permet de la référencer. Par exemple la table suivante est indexée par des chaines de caractères :

tab = {"cle1"="valeur1", "cle2"="valeur2"}
print(tab["cle1"]) -- va afficher "valeur1"

En Lua, les clés comme les valeurs sont polymorphes, c’est à dire qu’on peut aussi bien stocker des chaines de caractères avec des tables ou encore des fonctions ou tout autre type de valeur :

tab = {
  [1]="exemple",
  "2"="de",
  [function() return 3 end]="table",
  [false]="polymorphe"
}
 
for k, v in pairs(tab) do
  print(k, v)
end

Affichera :

1                 exemple
2                 de
function: 10f6840 table
false             polymorphe

Même l’environnement global ( _G ) est une table !

C’est donc dans cette optique là que l’on peut manipuler le Lua sous forme de langage objet, avec chaque objet une table et chacun des éléments de cet objet une méthode ou une propriété. Par la suite, si l’on veut créer un nouvel objet, il suffira de copier la table « modèle » (concept des meta-table). Pour créer des classes d’objets hérités on procédera de la même manière, sauf qu’on modifiera certaines méthodes.

myObject = {
    nom="toto",
    age=21,
    ChangerNom=function(self, nom)
        if #nom > 1 then
            self.nom = nom
        end
    end,
    ChangerAge=function(self, age)
        if age > 1 then
            self.age = age
        end
    end
}

Et accéder très facilement à chacun des éléments :

print(myObject.age) -- affiche 21
myObject:ChangerAge(18) -- identique à myObject.ChangerAge(myObject, 18)
print(myObject.age) -- affiche 18

Il faut comprendre cependant qu’il n’y a pas de notion d’espaces publiques et privés comme en C++/C#/Java, car c’est simplement une représentation, pas une réelle implémentation.

De cette manière vous devez enfin comprendre pourquoi on écrit platform.window:width() et non une variable ressemblant à « GetWindowWidth() ». En effet, width() est une méthode de l’objet window qui est une propriété de l’objet platform. Pareil pour platform.gc() que l’on retrouve abrégé en gc. En réalité, gc est un objet et platform.gc() en est son constructeur. D’un côté, c’est donc la même chose (ils ont tous les deux les mêmes méthodes) mais de l’autre non (ils ont des propriétés quelque peu différentes).

Nous allons donc, pour illustrer ce principe, créer ensemble un script Lua qui nous permettra de créer une et une seule fois une classe Forme ayant plusieurs méthodes dont un constructeur permettant de créer plusieurs formes.

Dans l’API Lua de la TI-Nspire, on trouve une méthode « class() » qui ne provient pas du Lua. En réalité, cette méthode économise certaines lignes qui peuvent paraître incompréhensibles.

Ces lignes sont :

Account = {}
Account.__index = Account
 
function Account.create(balance)
    local acnt = {}             -- our new object
    setmetatable(acnt,Account)  -- make Account handle lookup
    acnt.balance = balance      -- initialize our object
    return acnt
end
 
function Account:withdraw(amount)
    self.balance = self.balance - amount
end
 
-- create and use an Account
acc = Account.create(1000)
acc:withdraw(100)

Source : http://lua-users.org/wiki/SimpleLuaClasses

Maintenant, la même chose en utilisant class() :

Account = class()
 
function Account:init(balance)
    self.balance = balance      -- initialize our object
end
 
function Account:withdraw(amount)
    self.balance = self.balance - amount
end
 
-- create and use an Account
acc = Account(1000)
acc:withdraw(100)

Avouez que cela est plus clair ?
Il est à noter également que init() est un constructeur. Le nom de ce constructeur est contraint par la méthode class() qui appelle ce dernier pour compléter la construction avec setmetatable().

Nous pouvons donc créer très facilement notre classe Forme :

Forme = class()
 
-- Constructeur
function Forme:init(x, y, image)
    self.xpos = x
    self.ypos = y
    self.pic = image
end
 
-- Dessiner la forme
function Forme:paint(gc)
    gc:drawImage(self.pic, self.xpos, self.ypos)
end
 
-- Repositionner l'objet en indiquant les nouvelles coordonnees
function Forme:setxy(newx, newy)
    if newx > xmin and newx < xmax and newy > ymin and newy < ymax then
        self.xpos = newx
        self.ypos = newy
   end
end
 
-- Repositionner l'objet en indiquant le deplacement a effectuer
function Forme:move(dx, dy)
    local newx,newy
    self:setxy(self.xpos + dx,self.ypos + dy)
end

Vous aurez surement remarqué l’utilisation de variables globales, xmin, ymin xmax et ymax.

xmin = 20
ymin = 30
xmax = 250
ymax = 200

Nous pouvons enfin jouer avec notre classe Forme ! Pour cela nous allons créer deux images et les convertir en TI.Image en utilisant l’outil préliminaire de développement :

carre_rouge = image.new("\010\000\000\000\010\000\000\000\000\000\000\000\020\000\000\000\016\000\001\000\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252\227\252")
smiley = image.new("\016\000\000\000\018\000\000\000\000\000\000\000 \000\000\000\016\000\001\000\156\243\156\243\156\243\189\247\213\222\235\193\136\181g\181\135\181g\181\137\185O\202\189\247\156\243\156\243\156\243\156\243\156\243{\239O\206\168\222F\243D\243d\247d\247#\243\004\235E\214\170\1858\231\156\243\156\243\156\243\213\222m\210\231\230d\247\132\251\195\255\131\255\131\255\131\255C\251\003\247\132\226\233\193r\210z\239\156\243\204\189\198\226\132\247\166\218\007\198\198\226\195\255\131\255#\243\231\197\007\198\002\251\131\230\135\185\246\222\212\218g\210D\243\166\218\166\218\197\226D\239\131\255\131\255C\247\165\218d\222\006\206\194\242\196\205O\206\170\185\005\239\131\255\197\226D\239\131\255\131\255\131\255\131\255C\251\034\255\002\255E\218\226\250b\234\167\193G\173C\247\131\255\131\255\130\218\001\198\162\222\131\255c\251\002\243\161\197\161\197\226\250\226\250\162\246\133\193f\181#\243C\251\131\255\194\193\194\156\002\202C\251\034\255\162\234\194\156\194\156\193\250\193\254\193\254\133\193g\181\003\247c\251\034\255\196\230e\218\196\234\034\255\034\255\226\242%\218%\218\226\250\226\250\161\254\133\193&\169\226\242\034\255\034\255\034\255\034\255\034\255\002\255\002\255\193\254\193\254\226\250\161\254\161\254\161\254d\189G\173\163\234\002\255\226\242\194\242\163\234\162\242\162\242\162\242\130\238\130\242B\242\130\242\162\246B\242\133\193\014\198E\214\194\242f\181\198\156\231\156\231\156\231\156\231\156\231\156\231\156\198\156\231\156B\242\227\213\235\197Y\235\136\185\130\238\193\254\132\189s\206\222\251\222\251\222\251\222\251{\239\198\156\130\242\129\254d\189\179\214\156\243\237\193\196\205\162\242\162\242\198\201)\165)\165)\165)\165H\173B\242\129\254\227\213\169\193\023\227\156\243z\239\137\185\034\226\162\246\130\242B\234\034\230\034\230B\234\034\234\129\254\130\242D\181\213\222\156\243\156\243\156\243\023\227\201\197\002\222\162\246\161\254\129\254\161\254\129\254\129\250\034\234d\189\147\214\156\243\156\243\156\243\156\243\156\243\246\222\011\206\196\205\002\222B\238\034\238\034\230\196\209\165\197\147\214{\239\156\243\156\243\156\243\189\247\156\243\156\243\023\227p\210\011\206\198\205\198\205\232\205O\210\147\214\156\243\156\243\156\243\156\243")
forme1 = Forme (xmin + 20, ymin + 20, smiley)
forme2 = Forme (xmax - 30, ymax - 30, carre_rouge)

Dorénavant il ne nous reste plus qu’à créer la structure principale en utilisant divers évènements afin de tester toutes les possibilités de la classe que nous venons de créer.

-- Affichage
function on.paint(gc)
    gc:setColorRGB(231, 231, 231)
    gc:fillRect(xmin, ymin, xmax-xmin+15, ymax-ymin+15)
    forme1:paint(gc)
    forme2:paint(gc)
    gc:setColorRGB(0, 0, 255)
    gc:setFont("sansserif" , "b", 11)
    x = gc:drawString("(" .. forme1.xpos..", ".. forme1.ypos .. ")", 50, 0, "top")
end
-- Permet de deplacer forme1 avec les fleches directionnelles
function on.arrowLeft()
    forme1:move(-5, 0)
end
 
function on.arrowRight()
    forme1:move(5, 0)
end
 
function on.arrowUp()
    forme1:move(0, -5)
end
 
function on.arrowDown()
    forme1:move(0, 5)
end
-- Permet de choisir l'emplacement de forme2 avec la souris
function on.mouseDown(wx, wy)
    forme2:setxy(wx, wy)
end

Et voilà le résultat !