[mshell] Turtlegraphics

[lento]

Quanto qui riportato nasce con l'idea di aiutare la comprensione del concetto di funzioni e di Moduli.

Rendendo divertente, e semplice la programmazione. Mi sono rifatto al linguaggio Logo (Solo la parte grafica).

Il modulo che allego dovrebbe permettervi di creare facilmente funzioni, e imparare mShell.

Ho corretto svariati errori, aumentato la velocità in esecuzione, e reso indipendente dalle dimensioni di schermo.

Ora il modulo si adatta allo schermo del vostro cellulare.

In oltre ho reso modificabile il nome del modulo (anche se consiglio di continuare a chiamarlo turtleg.mm )

turtleg0.2.txt Per tutti i cellulari.

(rinominare turtleg0.2.txt in turtleg.mm)

Ho aggiunto anche nuove funzioni.

Il modulo turtleg contiene i seguenti comandi:
------------------funzioni---------------------------------------
pe()  = penerase	trasforma la penna in gomma da cancellare (in effetti assegna alla penna
				lo stesso colore del fondo)
ht()  = headturtle  nasconde alla vista la tartaruga (rendendo più veloce il disegno)
st()  = showturtle  rende visibile la tartaruga mentre disegna
cs()  = clearscreen pulisce lo schermo non modifica le coordinate ne l'orientamento della tartaruga.
home()= tana o casa riporta al centro dello schermo la tartaruga la orienta a gradi 0.
				non modifica le restanti impostazioni.
draw()= disegna	 resetta tutto all'origine pulendo lo schermo (porta in centro tartaruga orientata a 0°
				imposta penna nera fondo bianco rende attiva la penna.
rt(gradi)= right	destra orienta di N. gradi la tartaruga a destra. 
lt((gradi)= left	sinistra orienta di N. gradi la tartaruga a sinistra. 
fd(passi)= forward  avanti N. passi fa avanzare la tartaruga e se la penna è "down" disegna un passo
				corrispone ad un pixel dello schermo.
bk(passi)= back	 indietraggia di N. passi la tartaruga e se la penna è "down" disegna.
setx(coordinatax)=  (va a x) sposta la tartaruga alla coordinata assoluta x indicata se la penna e "down"
				disegna non modifica l'orientamento dei gradi che la tartaruga possiede.
				ricordarsi che lo schermo è diviso in quattro quadranti (piano cartesiano) perciò x a destra
				del punto 0 ha valori positivi x alla sinistra del punto 0 ha valori negativi.
sety(coordinatay)=  come setx() ma ci si riferisce alle coordinate asse Y.
random(da,ad) = random genera numeri casuali dal valore (da) fino al valore (ad) compreso.
spc(colore) =   setpencolor assegna il colore alla penna ci sono 16 colori numerati da 0 a 15 come in tabella
			0=nero		4 =porpora	8 =arancione   12=grigio2
			1 =bianco	 5 =verde1	 9 =marrone	 13=verde2
			2 =rosso	  6 =blu2	   10=rosso1	  14=azzurro
			3 =blu1	   7 =giallo	 11=grigio1	 15=grigio3
			ma volendo si puo assegnare qualsiasi colore col metodo (0Xffffff)
			per questioni di programma i numeri compresei tra 0X100000 e 0Xf00000 non funzionano
			(vengono visti come 1-2-3-4-5 della tabella sopra riportata.)
sbg(colore) = setbackground assegna colore al fondo (Stessi colori di spc())
setxy(x,y) = sposta la tartaruga alle coordinate assolute x,y se la penna è "down" disegna ma non modifica
		 l'orientamento della tartaruga.
xcor()= coordinata x rende il valore assoluto di x della posizione attuale di tartaruga.
ycor()= cpprdinata y rende il valore assoluto di y della posizione attuale di tartaruga.
pc()= rende il colore della penna (0-15) o gli altri se non si sta usando i colori numerati.
bg()= rende il colore del fondo (0-15) o altri.
getco() = rende il colore attuale del punto su cui si trova tarta. (0-15) corrispondenti a tabella o altri colori.
--------------------------------variabili modificabili----------------------------
pen= variabile a cui assegnare "up" per alzare la penna o "down" per abbassare
		   puo essere usata per conoscere lo stato della penna.
heading= gradi variabile che contiene l'orientamento della tarta 0° punta in alto 180° punta in basso ecc..
		   può essere impostata per orientare in maniera assoluta la tarta rispetto al piano.

Allego anche un programma di esempi che carica il modulo turtle.mm esempi0.2.txt

Dove in modo facile si generano oggetti grafici riutilizzabili.

// disegna un quadro alla turtle
function quadro(lato)
for a=1 to 4 do
 t.fd(lato); t.rt(90);
end;
end;

Questa è una fuzione che disegna un quadrato.

// disegna un rosone usando i quadri
function rosone(lato) 
t.draw();
for z=1 to 36 do
  quadro(lato); t.rt(10);
end;
end;

che può essere riutilizzata per generare un rosone come questo:

E con gli altri esempi si fa questo

o questo

Ci sono nell'esempio anche funzioni ricorsive.

Si può facilmente crearsi un alfabeto grafico, casette, ed altro......

Non ho testato a fondo le funzioni ci possono essere errori comunque...... più in là posterò aggiornamenti ed altri esempi più interessanti.

Come dice Alter....Lento ama il Logo perchè la sua mente semplice non gli permette di contenere altro!.

E' vero! mentre sono sparso per il mondo per questioni di lavoro, mi rilasserò impartendo semplici comandi al mini Logo....

Se qualcuno trovasse divertente il tutto si può portarlo avanti. Fatemi sapere.

Edited November 29, 2009 by lento

[Ra_]

puoi ordinare tutte le tue lezioni e magari le metti in un bel sito web??

anche per avere un ordine mentale di quello che pubblichi! è un bel lavoro!

[lento]

'Ra_' ti ringrazio per la tua alta considerazione di mè!

Dare una disposizione più organica di quanto scritto si può fare, ma risulterebbe ugualmente frammentaria ed incompleta.

Non essendo lezioni (Lò già detto "non sono in grado", ne ho le competenze di fare lezioni)

Sono solo delle spiegazioni visionarie nate volta per volta e stimolate da richieste specifiche.

Comunque se hai un idea di come vorresti fosse il tutto sono disponibile.

Per il sito Web.....e che! me voi fa morì de paura solo sperduto nell'oceanico web?...stò così bene qui in Nokioteca

[lento]

Ho notato che la tartarughina come interesse rasenta quasi lo Zero assoluto?

(Ringrazio ancora 'Ra_' per il suo interesse.)

Ora, o nel forum girano esclusivamente professionisti dell'informatica,

(in tal caso spero almeno di averli fatti sorridere!), o tutti sono esperti di Logo!.

Ma sono convinto che con il cellulare in mano ci sono molte persone che non hanno nulla

a che spartire con la programmazione. E forse vorrebbero provare a giocherellarci un pò.

Quello che mi prefiggo con tarta (vezzeggiativo di tartaruga)è proprio questo.

Giocare, programmare, in modo semplice.

Per cominciare bisogna che installiate mShell (non mi dilungo su questo.).

Una volta fatto bisogna copiare turtleg0.2.txt (rinominato turtleg.mm) dove si trovano i

programmi pre-installati di mShell.

Ora con l'editor di mShell o con un editor esterno create il vostro primo programma.

(che sò potete chiamarlo primo.m )

Un ultimo sforzo: La prima righa da scrivere è la seguente:

use turtleg as t, graph as g;

per ora non chiedetevi cosa significa, fatelo per fede!.

Ok!.

Ora siete pronti a sbizzarrire la vostra creatività!.

Provate a scrivere (su una linea nuova) t.draw(); sleep(2000);

(considero che state usando l'editor incorporato.) scritto il tutto dal menu File

scegliete Save & Go che salva quanto scritto e esegue il programma.

use turtleg as t, graph as g;

t.draw(); sleep(2000);

Dovrebbe apparire un cerchietto al centro dello schermo! quella è tarta

(per mia incompetenza non sono in grado di disegnare una tarta che indichi dove punta il muso, senza rendere

eccessivamente lento il programma.) perciò dovrete lavorare un pò di fantasia!.

La tarta si trova al centro schermo col muso che guarda in alto 0° pronta a disegnare secondo i vostri comandi.

La tarta si muove su un piano cartesiano come riportato in figura.

(Piccola nota: sleep(2000) è un comando di mShell che blocca il programma per 2000 millisecondi)

Ora proviamo a far muovere la tarta con il comando t.fd(passi) ordina alla tarta di avanzare

di un valore numerico pari a quanto assegnato in passi.

use turtleg as t, graph as g;

t.draw();
t.fd(100);
sleep(2000);

(Piccola nota: il punto e virgola è richiesto da mShell serve ad indicargli dove termina un comando.)

Riavviate il programma come sopra dovreste veder la tarta schizzare in alto di 100 pixel lasciando dietro di sè una riga. (la tartaruga si sposta sullo schermo come se avesse una penna abbassata che descrive il movimento che fà.)

Ormai esperti programmatori ci lanciamo in acrobazie, ordiniamo a tarta di ruotare a destra di 90°

con l'apposito comando t.rt(90) ora chiederemo a tarta di avanzare ancora di 100 passi.

use turtleg as t, graph as g;

t.draw();
t.fd(100);
t.rt(90);
t.fd(100);
sleep(2000);

chiediamo di ripetere ancora due volte i comandi ruota 90° avanti 100 e avremo di nuovo la tarta al cemtro schermo

con la testolina orientata a 0° ed avrà lasciato come traccia un quadro.

use turtleg as t, graph as g;

t.draw();
t.fd(100);
t.rt(90);
t.fd(100);
t.rt(90);
t.fd(100);
t.rt(90);
t.fd(100);
t.rt(90);
sleep(2000);

Ultimi sforzi!: mShell permette di contenere in un nome tutto un insieme di comandi in questo modo:

function quadro()
t.fd(100);
t.rt(90);
t.fd(100);
t.rt(90);
t.fd(100);
t.rt(90);
t.fd(100);
t.rt(90);
end;

questo nome si trasforma in un comando in grado di eseguire quanto scritto al suo interno

function è una parola speciale di mShell che serve per creare un nuovo nome/comando le due parentesi () sono obbligatorie come pure end; che serve ad indicare

dove terminano le istruzioni da assegnare al nome appena creato.

La parola quadro() scritta come sopra indicata è diventata a tutti gli effetti un comando,

o se preferite vederlo come un oggetto in grado di disegnarsi, e rappresenta un quadrato di lato 100 pixel.

Ora che l'abbiamo creato possiamo metterlo in funzione per far questo basta scrivere il suo nome successivamente

nel programma.

use turtleg as t, graph as g;

t.draw();
function quadro()
t.fd(100);
t.rt(90);
t.fd(100);
t.rt(90);
t.fd(100);
t.rt(90);
t.fd(100);
t.rt(90);
end;

quadro();
sleep(2000);

Certo che il comando quadro() è interessante ma sarebbe ancora meglio poter disegnare dei quadri con lati di dimensioni diverse!.

Per far questo al comando (o oggetto) quadro() dobbiamo poter passargli la misura

del lato che vogliamo!.

Questo in mShell è possibile mettendo il valore del lato che vogliamo passargli tra le due parentesi in questo modo.

quadro(50) anche la creazine del comando va un po modificata:

use turtleg as t, graph as g;

t.draw();
function quadro(lato)
t.fd(lato);
t.rt(90);
t.fd(lato);
t.rt(90);
t.fd(lato);
t.rt(90);
t.fd(lato);
t.rt(90);
end;

quadro(100);
quadro(65);
quadro(50);
quadro(20);
sleep(2000);

Ora con la nostra parola quadro() possiamo creare tutti i quadri che vogliamo!.

Per ora è tutto:

Se dovesse interessare a qualcuno lasciate un messaggio vedrò di continuare....

Edited November 29, 2009 by lento

[lento]

Riecchime! Speravate che fosse finita lì.....ennno! enno! troppo bello!.

Per più esperti:

La scelta di tarta è legata alla possibilità di vedere le funzioni come "oggetti".

No! non mi sto riferendo alla programmazione ad oggetti!. mi riferisco a cose reali.

Se creo una funzione fiore con tarta in mente ho un oggetto il fiore legato ad un nome

che guarda caso è pure una funzione.

Diventa più facile capire cosa possiamo farci con gli oggetti se rappresentano cose reali!.

Anche reali/irreali...che stai a dire? o rintronato del web! sì è un giochetto di parole

per introdurre degli oggetti che per loro natura sono irreali o meglio frutto del pensiero, i NUMERI.

Con tarta facciamoci tante funzioncine per disegnare i numeri!

Non saranno eccessivamente belli però....

Consideriamo che il numero deve stare in un rettangolo alto un unità largo mezza unità e lo spazio tra un numero e l'altro sarà di un quarto di unità.

l=lato alto lato corto=l/2 interspazio tra i numeri l/4 OK!.

Ecco come risulta la funzioncina per disegnare lo zero:

function zero(dim);
t.fd(dim); t.rt(90);  t.fd(dim/2); t.rt(90); // disegna rettangolo
t.fd(dim); t.rt(90);  t.fd(dim/2);
t.pen="up"; t.bk((dim/2)+(dim/4)); t.pen="down"; // si posiziona per nuova lettera 
t.rt(90);
end;

Parte dalla posizione attuale della tarta disegna il numero si sposta di 1/4 di lato e si prepara disegnare altro.

Notate che tarta si trova sempre in basso a sinistra ed è rivolta sempre col muso in alto (rispetto al numero).

Così facendo possiamo costruire tutti e 10 i numeri e recitando in coro il loro nome scrivere una sequenza.

t.draw(); t.ht();
t.pen="up"; t.setx(-110); t.pen="down";
zero(20); uno(20); due(20); tre(20); quattro(20); cinque(20); sei(20); sette(20); otto(20); nove(20);
sleep(2000);

Ecco cosa risulta:

Bello! bravo! che barba! ma guarda se devo sta lì a scrivere un metro di testo per vedere 0123456789 !

Alter calma! un pò per volta!.

I nostri numerini sono funzioni che possiamo dimensionare come vogliamo! ma mShell permette di fare una cosa importante!

Passare il puntatore di una funzione ad una variabile o meglio ad una matrice!.

Per chi non lo sapesse un puntatore non è altro che il solito spione (Chi da piccolo a scuola o all'asilo non ha

avuto a che fare con lo spione) Maestra! Maestra! guardi! Pierino si è nascosto in palestra!

Se abbiamo la funzione zero() possiamo creare il solito spione in questo modo:

spione=&zero; ora spione conterrà quel deprecabile personaggio che punterà, indicherà dove realmente si trova, (si nasconde) la funzione zero() rendendola attiva.

nu=[&zero,&uno,&due,&tre,&quattro,&cinque,&sei,&sette,&otto,&nove];

In questo modo ho creato un array nu[] pieno di spioni, uno per ogni numero.

per metterli in azione bisogna scrivere:

nu[0](50); questo attiverà lo spione che prontamente indicherà dive si nasconde la funzione zero()e la obbligherà a eseguirsi utilizzando il valore 50. come se la chiamassimo così

zero(50).

Per stampare i numero come sopra ora basta fare così: for a=0 to 9 do; nu[a](15); end;

UUUU che mago! UUUU....uuuuu. Ei! Alter basta!

Guarda un pò ste esempi:

t.draw(); t.ht();
for aa=0 to 18 do
t.home(); t.rt(aa*20);
for a=0 to 9 do; nu[a](15); end;
end;
sleep(2000)

t.draw(); t.ht();
for aa=0 to 18 do
t.home(); t.rt(aa*20); t.spc(t.random(2,15));
for a=0 to 9 do; nu[a](15); end;
end;
sleep(2000)

t.draw(); t.ht(); t.spc(3); passo=2;
for aa=0 to 18 do
t.home(); t.rt(aa*20);  passo=passo+2;
for a=0 to 9 do; nu[a](passo); end;
end;
sleep(2000)

t.draw(); t.ht();
for aa=0 to 10 do
t.pen="up"; t.setx(-110+aa); t.sety(0+aa);t.pen="down";
t.spc(3+aa); passo=30;
for a=0 to 9 do; nu[a](passo); end;
end;
sleep(2000)

t.draw(); t.ht(); 
for aa=0 to 10 do
t.pen="up"; t.setx(-110+aa); t.sety(0+aa);t.pen="down";
t.spc(3+aa); passo=20;
for a=0 to 9 do; nu[a](passo+(a*3)); end;
end;
sleep(2000)

t.draw(); t.ht(); t.pen="up"; t.bk(100); t.lt(180); t.pen="down";
passo=10;
for z=0 to 3 do
t.spc(z+3);
for aa=1 to 8 do
	for a=0 to 9 do; nu[a](passo); end; t.rt(45);
end;
passo=passo-2;
end;
sleep(2000)

Più in là parleremo di questa:

lnu=["0":&zero,"1":&uno,"2":&due,"3":&tre,"4":&quattro,"5":&cinque,"6":&sei,"7":&sette,"8":&otto,"9":&nove];

Per ora se a qualcuno interessa fatevi l'intero alfabeto! alla faccia di Alter!.

Ha dimenticavo qui ci sono gli esempi sopra riportati: numeri0.0.txt

Edited November 29, 2009 by lento

[Nick_7]

veramente molto interessante, poi nell'penultimo post l'hai spiegato così bene che sono riuscito a capirlo persino io vedrò di provarlo anche se ho il touch...

Edited November 29, 2009 by Nick_7

[lento]

veramente molto interessante, poi nell'penultimo post l'hai spiegato così bene che sono riuscito a capirlo persino io vedrò di provarlo anche se ho il touch...

'Nick_7' il touch è uno dei motivi che mi ha spinto a fare tarta.

Come puoi notare si può eseguire su tutti i tipi di cellulari Nokia, non richiedo mai l'uso di tasti o altro.!

Qualsiasi dimensione di schermo va bene!.

Spero solo che per cell un pò datati tarta sia sufficentemente veloce!.