[EasyUO-Req] Delucidazioni su una mia sub

[Jullette]

Sub Muoviti

;===== inizio interrogazione sulla direzione della mia barca ========
If #chardir <> 0
            {
            repeat
            msg turn left $
            wait 2s
            until #chardir = 0
            }
;===== fine interrogazione ========

IF %memorymovimento = 1
         {

         set %posizioneattuale #CHARPOSY
         repeat
         msg forward one $
         wait 1s
         until #CHARPOSY = %posizioneattuale - 30
         goto inizio
         
         }

;(%memorymovimento = 1 l'ho settata in un altra sub precedente nella quale controllo se ho avuto un gain della skill)

ok, questo è il pezzo che mi da' noie.

Allora, ho testato in locale (e non in barca) lo script completo. Funziona. Appena ho un gain della skill il pg inizia a dire forward one, io lo sposto di 10 tile, lui smette e ricominci il cast.

Ho finito ora di provare sul server sulla barca ma non mi finziona. Ho notato che sulla barca non riesce ad "intercettare" questa condizione

until #CHARPOSY = %posizioneattuale - 30 (*)

non riesco a trovarmente il motivo, cioè insomma, è dovuto alla lag??

Scusate la niubabgine ma sto' cercando di imparare a fare qualcosa che si possa chiamare script.

Grazie a tutti x l'aiuto.

Auguri

Icq, 245055152

(*) ho notato che in barca quando dico forward one, il #charposy si decrementa di 3 ed è x quello che metto 30 e non 10

P.S. So' che il primo ciclo if non portà mai funzionare su una barca

[Boydon]

A parte che non vedo il return della sub, cmq hai provato a mettere delle parentesi o salvarti il valore su una variabile prima di fare il confronto?

until #charposx = ( %posizioneattuale - 30 )

oppure

set %posizioneattuale #CHARPOSY
set %posizionedesiderata %posizioneattuale - 30
repeat
msg forward one $
wait 1s
until #CHARPOSY = %posizionedesiderata

A volte il parser di EUO è un po scrauso.

[Jullette]

non ho messo il return xkè ho messo il goto inizio (he mi fa ripartire lo script dal cast della spell)

Le parentesi le ho messe ma non vedo differenze.

Provo ancora a mettere

set %posizioneattuale #CHARPOSY
set %posizionedesiderata %posizioneattuale - 30

Bho, comunque ho provato in locale sulla barca, e pare che funzioni (ho fatto steppato con F7) a parte il fatto che non mi fa' il quadrato ma mi fa un rettangolo, ma l'ho già modificato.


Uhm... scusa la niubbagine ma esiste qualcosa per far considerare allo script l'eventuale lag?

Ciau e grazie

[Boydon]

Fare goto fuori da una sub non è consigliabile perchè, oltre a essere una pessima abbitudine di scrivere codice, può anche (raramente) far crashare EasyUo, quindi ti consiglio di sistemare .

Puoi considerare la lag in vari modi, dipende sempre che cosa devi fare.
Dammi qualche info in più che vedo di aiutarti.

[Jullette]

Fare goto fuori da una sub non è consigliabile perchè, oltre a essere una pessima abbitudine di scrivere codice, può anche (raramente) far crashare EasyUo, quindi ti consiglio di sistemare .

Puoi considerare la lag in vari modi, dipende sempre che cosa devi fare.
Dammi qualche info in più che vedo di aiutarti.

In effetti era solamente una mia idea quella della lag. Ho testato nuovamente lo script sul server e funziona bene, senza intoppi.

Mi hai messo xo' un po' di dubbi sulla prima parte del tuo reply...

Il goto l'ho messo nel ciclo if della Sub Muoviti

[Boydon]

Tu, dentro la tua sub muoviti, hai l'istruzione "goto inizio" solo che l'etichetta "inizio:" non è dichiarata all'interno di questa sub (cioè, se tu avessi messo il return, tutto quello compreso tra sub muoviti e return), perciò deduco che sia dichiarata altrove nello script.

Questa è una cosa che ti sconsiglio di fare per i motivi citati prima.
È anche sottolineato nella documentazione di EasyUO: http://www.easyuo.com/wiki/index.php/Goto

[Jullette]

Vediamo se ho capito qualcosa

Metto al posto di goto inizio, return così mi riporta alla parte di codice dove è stata richiamata la sub muoviti e continua. In questo caso mi devo salvare una memory dentro il ciclo if e poi fare un controllo x farlo ripartire dall'inizio.

esempio

Inizio:
bla
bla
bla
gosub blabla
if  %memory = 1
goto inizio
bla 
bla 
bla


sub blabla

if blabla = bla
{
bla
bla
set %memory 1
return
}

Grazie x la disponibilità e della pazienza, questa cosa che mi hai detto nemmeno me la sarei sognata, Grazie

[Boydon]

Esatto.

Le sub, una volta che avrai imparato ad usarle bene sono uno strumento MOLTO potente e flessibile. Perchè, attraverso dei parametri ti permettono di riassumere operazioni di più righe di codice in una riga soltanto.

Ma ti faccio un esempio che forse è meglio; supponiamo che in uno script devi usare tre oggetti uno di fila all'altro.

Il codice, se non usi le sub sarà più o meno questo:

set %oggetto1 ABCDEF
set %oggetto2 GHIJKL
set %oggetto3 MNOPQR

set #lobjectid %oggetto1
Event Macro 17 0
wait 12
set #lobjectid %oggetto2
Event Macro 17 0
wait 12
set #lobjectid %oggetto3
Event Macro 17 0
wait 12
halt

Come vedi questo codice è ripetitivo. Usando una sub con dei parametri puoi accorciare il codice e renderti la vita un po più semplice. Per parametri intendo delle varibili che te passi alla sub e che poi usi successivamente all'interno di essa.
Ti faccio un altro esempio che è meglio:

set %oggetto1 ABCDEF
set %oggetto2 GHIJKL
set %oggetto3 MNOPQR

sub usa_oggetto
    set #lobjectid %1 ;%1 è il primo parametro
    Event Macro 17 0
    wait 12
return

gosub usa_oggetto %oggetto1 ; i parametri in euo sono passati in questo modo
gosub usa_oggetto %oggetto2
gosub usa_oggetto %oggetto3
halt

Questo codice fa esattamente lo stesso di quello sopra, ma lo fa utilizzando una sub con dei parametri. Ora cerco di spiegarti come.

Per chiamare una sub con dei parametri si fa in questo modo:

gosub nome_sub %parametro1 %parametro2 testo1 altrotesto ....

Se usi EasyUo 1.5 puoi usare un numero infitito di parametri, mentre con easyuo 1.42 ci sta il limite di 50 parametri (che sono comunque parecchi). I parametri, come vedi, non devono essere necessariamente delle variabili, ma possono anche essere fatti di semplice testo.

Una volta che sei dentro la sub per accedere ai parametri devi usare le variabili %1, %2, %3, ecc ecc sino al numero di parametri che ti servono e che hai passato. Inoltre, sempre dentro una sub, puoi accedere alla varibile %0 che ti dice quanti argomenti stai passando alla sub corrente (quindi nell'esempio dell'useitem %0 sarà uguale a 1).

È abbastanza semplice, no?

Ti metto un altro esempio semplice semplice.

set %testo1 parametro

gosub mostra_testo %testo1
gosub mostra_testo NatalieImbruglia

sub mostra_testo
    Display ok Il testo è " %1 " Questa funzione ha %0 parametri
return
halt

Puoi dichiarare le sub sia prima che dopo averle usate nello script, l'importante è che le metti da qualche parte, poi ci pensa EUO a trovarle. Le parentesi graffe non sono necessarie, io non le metto, ma per sub molto lunghe facilitano la lettura.

Un errore molto comune occorre quando chiami una sub dentro l'altra: quando chiami la prima sub potrai accedere a tutti i parametri con le varibili %1, %2, %3 ecc ecc quando poi vai a chiamare la seconda sub, a sua volta annidata nella prima i vecchi valori vengono sovrascritti, quindi se hai intenzione di riusarli li devi salvare. Al solito metto esempio.

set %oggetto ASDLOL

gosub usa_oggetto %oggetto

sub usa_oggetto
    set #lobjectid %1 ;%1 è uguale a ASDLOL
    Event Macro 17 0
    wait 12
    gosub mostra_testo Oggetto_usato!
    ; da questo punto in poi %1 non è + ASDLOL, ma Oggetto_usato!
return

sub mostra_testo
    Display ok Il testo è " %1 " Questa funzione ha %0 parametri
return
halt

Spero di essere stato chiaro.
Se ti serve chiedi altre spiegazioni.

[Jullette]

Non posso che ringraziarti x il tempo che mi concedi

Sei stato molto chiaro e mi hai dato nuovi spunti e nuovi dubbi :P

set %oggetto1 ABCDEF
set %oggetto2 GHIJKL
set %oggetto3 MNOPQR

sub usaoggetto

event sysmessage %1 
wait 1s
event sysmessage %2 
wait 1s
event sysmessage %3 
wait 1s

return


gosub usaoggetto %oggetto1 %oggetto2 %oggetto3

in questo caso mi troverò 3 sysmessage:
abcdef
ghijkl
mnopqr

Comunque: gosub usaoggetto parametri ---> attribuisce ai parametri %1, %2 etc.. ovvero %oggetto1 = %1, %oggetto2 = %2 etc...

Bene, riflettendoci un po' credo di esserci arrivato da solo. Infatti il mio dubbio erano proprio %1 %2 a cosa si riferivano. Credevo lo prendessero dall'assegnazione invece il riferimento lo prendono da:

gosub blabla %cane %gatto %topo

dove %cane nella sub è indicato come %1, %gatto è indicato come %2 e via discorrendo

Ancora una cosa:

set %oggetto ASDLOL

gosub usa_oggetto %oggetto

sub usa_oggetto
    set #lobjectid %1 ;%1 è uguale a ASDLOL
    Event Macro 17 0
    wait 12
    gosub mostra_testo Oggetto_usato!
    ; da questo punto in poi %1 non è + ASDLOL, ma Oggetto_usato!
return

sub mostra_testo
    Display ok Il testo è " %1 " Questa funzione ha %0 parametri e l'ultimo oggetto usato ha id #lobjectid
return
halt

ho aggiunto: "e l'ultimo oggetto usato ha id #lobjectid" che mi fa la finestrella con "il testo è "Oggetto_usato" Questa funzione ha 1 parametri e l'ultimo oggetto usato ha id ASDLOL


Grazie infinite x la pazienza

[Boydon]

Prego.

Ora che hai capito i parametri sei pronto per imparare ad usare a fondo anche il return mio giovane padawan.

Il return, oltre alla funzione di terminare una sub e di riportare euo alla line dove la sub era stata chiamata, può avere anche un'altra funzione aggiuntiva ossia quella di restituire "informazioni aggiuntive" (notare le virgolette). Ed è da questo che - credo - deriva il suo nome.

Come è possibile approfittare di questa opportunità?
Basta far seguire a return una variabile. Passo al solito esempio.

gosub somma 2 2 ;chiamo la mia sub
display ok La somma è %somma

sub somma
    set %somma %1 + %2
return %somma ;è in questo modo che "restituisco" informazioni aggiuntive
halt

A questo punto, le informazioni aggiuntive che te restituisci tramite questo comando vengono immagazinate da euo nella sysvar #result; perciò la seconda riga poteva comodamente essere:

gosub somma 2 2 ;chiamo la mia sub
display ok La somma è #result ;non uso %somma

sub somma
    set %somma %1 + %2
return %somma
halt

Questo esempio è molto semplice e non rende bene la potenza del return. La cosa f.iga infatti (ed è qui che si nota la potenza) è che oltre a semplici variabili puoi restituire veri e propri statement (ovvero operazioni aritmetiche, ma anche operazioni di confronto).

Ti rifaccio esempio pendendo spunto dalla sub di prima:

gosub somma 2 2 ;chiamo la mia sub
display ok #result

sub somma
return %1 + %2
halt

Comodo no?

Se hai familiarità con gli if pui fare altre cose molto comode e potenti, ti faccio un altro esempio facile:

gosub èmaggiore 3 2
if #result
    display ok È maggiore!
else
    display ok Mi sa che è minore... O è uguale??

sub èmaggiore
return %1 > %2
halt

Last, but not least spesso il return viene verificato per terminare una sub prima del previsto se si verificano particolari condizioni. Ti faccio un altro esempio (questo è un esempio stilizzato, non funzionante per farti capire il concetto):

....

gosub loota %corpo

sub loota
    
    ; apri il corpo
    ; cechi oggetti nel corpo
    if ( il corpo è vuoto )
        return ; interrompo subito la sub perchè non mi interessa lootare visto che il corpo è vuoto
    else
        ; codice per lootare

return

...

In questo abbozzo di sub, una volta che hai aperto il corpo controlli se è vuoto e se è così fai un bel return visto che comunque non ti interessa proseguire la sub.

Con questo credo sia veramente tutto sulle sub, altre info, se me le sono scordate (anche se non credo) le trovi nella documentazione ufficiale di EUO (qui).

Il modo migliore per impare resta sempre quello di guardare a script fatti da altri, io ho iniziato da quelli di Road Kill che sono abbastanza commentati bene. Altrimenti guarda quelli di CEO e perchè no, il mio BOD filler che anche lui è uno script completo che fa ampio uso di molte delle feature di EasyUO.

[Jullette]

Grazie

Ancora una cosa

gosub èmaggiore 3 2
if #result
    display ok È maggiore!
else
    display ok Mi sa che è minore... O è uguale??

sub èmaggiore
return %1 > %2
halt

sub èmaggiore
return %1 > %2 ---> mi restituisce la condizione o vera o falsa

if #result ( = vero ) <--- sottointeso?
bla bla
else
bla bla

Riflettendoci un poco sopra mi viene una domanda.

Con easy 1.5 la struttura Repeat/until è funzionante? e se si, a che livello?
Altrimenti mi verrebbero in mente dei cicli if x ovviare a questi problemi

[Boydon]

sub èmaggiore
return %1 > %2 ---> mi restituisce la condizione o vera o falsa

Si è esattamente così.

if #result ( = vero ) <--- sottointeso?
bla bla
else
bla bla

È sottointeso, ma non è omesso se è questo che intendi. In quella linea #result è esattamente identico a #true perchè è il risultato dello statement dopo il return della sub. In pratica cosa fa easyuo: quando trova un "if ( condizione )" con una condizione più o meno complessa (varie parentesi annidate con vari condizioni espresse con gli operatori && e ||) risolve via via tutti i livelli di complessità fino a ridurre la condizone ad un valore #true o ad un valore #false. In pratica scrivere un statement del tipo:

if #true
    ; codice

è sintatticamente corretto, anche se di poca utilità. Questo meccanismo può invece tornare molto utile nell'esempio del post precedente. A questo riguardo ti faccio notare che in EUO #false è esattamente uguale a 0 e #true e esattamente uguale a -1. Questa cosa è simile in molti altri linguaggi di programmazione con la sola differenza che il booleano (così si chiamano i tipi di variabile che possono essere o vere o false) per il true è sempre uguale a 1 (solo in easyuo è uguale a -1 e non chiedermi perchè). Tieni presente questa cosa perchè potrai sfruttarla a tuo vantaggio

Riflettendoci un poco sopra mi viene una domanda.

Con easy 1.5 la struttura Repeat/until è funzionante? e se si, a che livello?
Altrimenti mi verrebbero in mente dei cicli if x ovviare a questi problemi

Il repeat ... until funziona l'unica cosa è che, come ti ho già detto, euo a volte toppa e quindi bisogna stare molto attenti alle parentesi e agli spazi.
In alternativa puoi usare il while (che è MOLTO simile, ma ha una differenza fondamentale dal repeat ... until e cioè che lo statement viene valutato prima di eseguire il codice e non dopo), il for che è differente e di solito viene usato quando si conosce il numero di volte che si desidera iterare o, come dici te degli if unito all'uso di etichette e goto. Quest'ultima pratica (if in unione con goto e label) però io la sconsiglio perchè fa perdere di leggibilità al codice ed inoltre è facile incasinarsi con le etichette (soprattutto per script lunghi e complessi) e cmq è considerata una cattiva maniera di scrivere codice (ebbene si anche lo scrivere codice ha il suo "galateo" :P). Essendo cmq che il while e il repeat sono stati introdotti con la 1.5 di euo vedrai praticamente il 90% degli script usare la tecnica che io ti ho sconsigliato (era l'unica possibile!).

Non capisco che intendi quando mi chiedi a che livello lavora il repeat ... until.

[Jullette]

È sottointeso, ma non è omesso se è questo che intendi. In quella linea #result è esattamente identico a #true perchè è il risultato dello statement dopo il return della sub. In pratica cosa fa easyuo: quando trova un "if ( condizione )" con una condizione più o meno complessa (varie parentesi annidate con vari condizioni espresse con gli operatori && e ||) risolve via via tutti i livelli di complessità fino a ridurre la condizone ad un valore #true o ad un valore #false. In pratica scrivere un statement del tipo:

Ke *****, bastava che ci pensassi 3 secondi :/ ti chiedo scusa.

Non capisco che intendi quando mi chiedi a che livello lavora il repeat ... until

intendevo fino a che punto è "sicuro", comunque mi hai già risposto
Ero indeciso se usare repeat/untile oppure while e come mi hai fatto notare forse è meglio avere il controlla all'inizio della struttura piuttosto che alla fine.

Credo sia tutto

Grazie di tutto

Ah, già... x la lag ho risolto tutto inserendo un > (o minore) dove necessario x verificarne la condizione... è una roba un po' incasinata dove mi dovevo spostare di tot tile se ho avuto 3 gain. Mi dava problemi con la lag, infatti quando ci sono le botte, lo script mi faceva dire lo stesso forward one in loop e poi quando si sbloccava mi riportava ad una coordinata maggiore di quella richiesta ed infatti la condizione non si verificava.

[Boydon]

Un ultima cosa sulla differenza tra while e repea (perchè non so se sono stato chiaro :P), ti metto del codice abbastanza chiaro, se non è di aiuto chiedi pure.

set %variabile #false

while %variabile = #true
{
    display ok Questa linea non sarà mai eseguita
}

repeat
    display ok Questa linea sarà sempre eseguita
until %variable = #true
halt

In questo caso cmq dei buoni controlli sulla lag potresti farli tramite il journal e verificare che la frase che vuoi dire sia stata effettivamente pronunciata. Se ci sta lag il tuo messaggio "forward" non verrà pronunciato e non sarà perciò memorizzato nel journal. Finche non appare aspetti e solo dopo controlli la posizione.

[Jullette]

Si, avevo pensato a dei controlli sul journal xo' alla fine a me non serve un granchè avere la scansione così precisa. Insomma, a me basta che la barchetta si fermi quando la distanza fra il punto a ed il punto b è = oppure anche > di 9

i while e i repeat li capisco (ricordi scolastici asdasdasd)


Boydon,ti ringrazio


P.S. ho letto (e non solo startato) il tuo script x bod...

Innanzitutto, ora che l'ho letto, ti faccio i complimenti e mi chiedo che razza di testa hai
Passando oltre i complimenti, ti dirò che ho capito qualcosa. Ovviamente non mi potevo ricordare tutte le %, quindi è stato un po' un casino, xo' sono soddisfatto