Interessante guida alla programmazione per il progettista - Controllo del processo del programma - Dichiarazione del ciclo: 8 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:05

Dichiarazione del ciclo di controllo del processo del programma

Da questo capitolo, entrerai in contatto con un'importante e potente dichiarazione punto-ciclo di conoscenza.

Prima di leggere questo capitolo, se vuoi disegnare 10.000 cerchi nel programma, puoi farlo solo con un metodo terribile. Cioè scrivere 10.000 righe di codice ellittico. Quei pigri progettisti di codice che vogliono migliorare l'efficienza con tutti i mezzi, sicuramente non permetterebbero che ciò accada. Quindi, viene creata l'istruzione loop. Con questa affermazione, puoi sentire intuitivamente la potenza dell'automazione del computer.

Passaggio 1: per il ciclo

Ci sono molte istruzioni di loop, tra cui la più utilizzata è For Loop. Sappiamo tutti che la funzione draw è continuamente in circolazione. Inizia dalla prima frase all'inizio, attuerà dall'alto verso il basso fino all'ultima frase. Dopo aver terminato un'operazione, ricomincerà dalla prima frase. L'istruzione For è un po' simile alla funzione draw. Il codice all'interno dell'istruzione for può essere eseguito ripetutamente.

Ecco la sua struttura grammaticale:

For(espressione 1; espressione 2; espressione 3){

Corpo ad anello

}

Ovviamente, le frasi all'interno del corpo del ciclo sono ciò che ci aspettavamo di essere implementate ripetutamente. L'espressione 1 viene utilizzata per inizializzare e assegnare il primo valore alla variabile di ciclo. L'espressione 2 è per la condizione del ciclo. L'espressione 3 aggiornerà il valore della variabile di ciclo.

Che cos'è la variabile di ciclo? In realtà è equivalente a una variabile locale. Diamo uno sguardo a uno scritto completo.

for(int i = 0;i < 10;i++){

Corpo ad anello

}

Per realizzare la funzione di ciclo, l'istruzione for si basa principalmente su una variabile locale, che verrà utilizzata alla fine del ciclo. La variabile locale nell'esempio sopra è i. L'espressione 1 ha completato l'inizializzazione della variabile locale. Successivamente, ogni volta che il ciclo funziona per una volta, questa variabile deve essere aggiornata. Nell'esempio precedente, i++ nell'espressione 3 viene utilizzato per realizzare la funzione di aggiornamento. Attraverso di essa, la variabile aumenterà di 1 ogni volta che viene aggiornata. Alla fine, il codice all'interno del corpo del ciclo non può eseguire il ciclo indefinitamente, altrimenti le ultime istruzioni non possono essere eseguite. Quindi, abbiamo bisogno di una condizione terminale. Express 2 è proprio per questo. Qui, il programma giudicherà se i è inferiore a 10. Se lo è, continua a operare. Se non lo è, salta fuori dal giro.

Pertanto, la sequenza di operazioni dell'istruzione for è proprio come questa.

Espressione 1 (inizializzazione variabile locale)

Espressione 2 (Soddisfatto, quindi continuare ad operare)

Corpo ad anello (prima circolazione)

Espressione 3 (Aggiornamento)

Espressione 2 (Soddisfatto, quindi continuare ad operare)

Corpo ad anello (seconda circolazione)

Espressione 3 (Aggiornamento)

Espressione 2 (Soddisfatto, quindi continuare ad operare)

Corpo ad anello (terza circolazione) …

Espressione 3 (Aggiornamento)

Espressione 2 (Non soddisfatto, quindi salta fuori dal ciclo)

Puoi simulare questa sequenza di esecuzione nella tua testa più volte. Ma è impossibile capire veramente il codice senza digitarlo con la mano per una volta. Quando vogliamo scoprire un concetto strano, possiamo stampare il valore nella console tramite l'istruzione println.

Esempio di codice (5-1): void setup(){

for(int i = 0; i < 10; i++){

println ("esegui");

}

}

Puoi contare il numero di output di esecuzione nella console. Qui è esattamente 10. Questo ti dice quante volte è stato eseguito il codice nel corpo del ciclo. Tuttavia, non siamo ancora in grado di rilevare quali modifiche siano effettivamente avvenute nel ciclo. Quindi possiamo provare a cambiare il carattere "eseguire nella variabile "i" e vedere cosa succederà.

Esempio di codice (5-2): void setup(){

for(int i = 0; i < 10; i++){

println(i);

}

}

Ora, possiamo vedere che il valore i nel corpo del ciclo è in continuo aumento. Successivamente, possiamo usare questo valore per comprendere il processo corrente del ciclo.

Nell'esempio di codice (5-2), il valore di i viene modificato da 0 a 9. Rispetto ai tempi di ciclo effettivi, sembra avere sempre 1 in meno. Se non ci si è abituati, l'espressione tra parentesi di for può essere scritta come segue:

for(int i = 1; i <＝ 10; i++)

Quindi, i corrisponde giustamente ai tempi del ciclo. Il significato di "<＝" è minore e uguale a. Quindi, quando i è uguale a 10, soddisferà comunque la condizione. Pertanto, funzionerà ancora una volta rispetto all'essere scritto in i < 10. Sebbene parta da 1, i tempi di ciclo sono ancora 10. Naturalmente, se non è necessario nulla di speciale, vorrei suggerire di adottare il metodo di scrittura nel esempio all'inizio. Più avanti ti presenteremo il vettore o l'array, entrambi i quali ottengono il suo elemento dal suo pedice. E i pedici predefiniti iniziano tutti da 0. Definire il valore iniziale come 0 è una pratica relativamente comune.

Nell'esempio sopra, se scriviamo i è maggiore di 0, il programma andrà in crash. Poiché la variabile è in costante aumento, non soddisferà mai questa condizione. È proprio come se non potesse mai essere interrotto in modo che il programma venga eseguito in un ciclo infinito.

Le variabili locali nell'istruzione for possono non solo dichiarare tipi plastici, ma anche dichiarare variabili in tipi a virgola mobile. Ad esempio, può essere scritto come (float i = 0; i <10; i + = 0,02).

Passaggio 2: utilizzare per Loop per risolvere problemi matematici

Ricordi ancora una storia del matematico Gauss nella sua infanzia? A quel tempo Guass aveva 10 anni. Il suo insegnante voleva assegnare un compito in classe e la domanda era

1＋2＋3＋4……＋97＋98＋99+100＝？

Se calcoli con le tue mani, ci vorrà molto tempo. Ma Guass sembra aver già capito il metodo di sommatoria della sequenza aritmetica. Quindi, subito dopo che la domanda è stata data, ha pronunciato la risposta con facilità, cosa che aveva molto sorpreso il suo maestro.

Ora, forse non ricordiamo ancora qual è la sommatoria della sequenza aritmetica ma possiamo ottenere la risposta in modo primitivo e violento. E questo è per il ciclo. Dal momento che è solo un piccolo pezzo di torta da contare per i computer, dobbiamo descrivere la domanda in un linguaggio che può essere riconosciuto dal computer, quindi possiamo facilmente ottenere la nostra risposta.

Esempio di codice (5-3):

void setup(){

int risposta = 0;

for(int i = 1; i <= 100; i++){

risposta += io;

}

println(risposta);

}

Credo che il risultato che ottieni sia lo stesso della risposta riportata da Guass: è 5050!

Suggerimenti: Il nome delle variabili locali nel ciclo for può essere modificato a piacimento a condizione che rispetti le regole di denominazione delle variabili. Puoi scriverlo come (int k = 1;k <= 100;k++). Se non si sono verificate condizioni speciali, il nome predefinito della variabile è i.

Passaggio 3: per il disegno in loop

Dopo una serie di letti apparentemente noiosi, finalmente possiamo entrare in una sezione più interessante. Questo è da usare per il ciclo per disegnare immagini. Ora possiamo mettere da parte quei noiosi calcoli matematici. Noi designer siamo più sensibili alla grafica.

Usa For Loop per disegnare una serie di cerchi

Quando vogliamo usare il ciclo for per rappresentare un gruppo di elementi ripetuti, dobbiamo assicurarci in anticipo la relazione numerica di questi elementi, quindi possiamo usare il ciclo for per realizzarlo comodamente invece di eseguire un massiccio lavoro di ripetizione. Supponiamo di voler disegnare una riga di cerchio equamente distribuita in direzione orizzontale. La sua coordinata virtuale è invariata mentre la sua coordinata orizzontale è cambiata. E da sinistra a destra, la coordinata orizzontale è in costante aumento e la distanza in aumento è la stessa. A questo punto, possiamo usare i in for loop per ottenere la coordinata orizzontale di ciascun cerchio.

Esempio di codice(5-4): void setup(){

dimensione (700, 700);

sfondo(83, 51, 194);

noStroke();

}

disegno vuoto(){

for(int i = 0; i < 7; i++){

ellisse(50.0 + i * 100.0, altezza/2.0, 80.0, 80.0);

}

}

50 sta per la posizione di partenza del primo cerchio a sinistra. 100 in i * 100 rappresenta la distanza crescente.

Passaggio 4: utilizzare per Loop per disegnare un punto rotondo casuale

La posizione del grafico sopra è prevedibile. Ciò ridurrà al minimo l'interesse. Possiamo usare la funzione random a cui abbiamo fatto riferimento nel capitolo precedente e provare a scriverla nella funzione disegno.

Esempio di codice (5-5):

void setup(){

dimensione (700, 700);

sfondo(0);

noStroke();

}

disegno vuoto(){

sfondo(0);

for(int i = 0;i < 10;i++){

float randomWidth = random (60.0);

ellisse(random(larghezza), random(altezza), randomWidth, randomWidth);

}

}

Qui, il motivo per cui la posizione del cerchio lampeggia continuamente è perché ogni volta che la funzione casuale funziona per una volta, il risultato è casuale. Poiché la funzione di disegno è impostata per impostazione predefinita per eseguire 60 fotogrammi al secondo, quindi ogni 10 cerchi disegnati in un secondo cambierà la sua posizione per 60 volte. Questo flash veloce fa sembrare che l'immagine abbia più di 10 cerchi. Cambiare un semplice valore nel programma ti darà un effetto completamente diverso. Possiamo cambiare i tempi del ciclo rivedendo la condizione del terminale. La condizione del terminale nell'immagine sotto è i < 100

1. Ecco l'effetto quando la condizione del terminale è i < 1000:
2. Seme casuale
3. Se non voglio che la posizione del cerchio sia generata casualmente così come il suo flash, cosa posso fare? Un metodo consiste nel creare e memorizzare variabili indipendenti per ogni cerchio e inizializzare queste variabili durante l'impostazione. Assegna a queste variabili un valore casuale. Pertanto, quando si utilizza la funzione di disegno all'interno di draw, ciò che abbiamo invocato è il valore memorizzato in variabili. Non cambierà in nessun momento. Per disegnare 10 cerchi possiamo semplicemente usare questo metodo. Ma cosa succede se volessimo disegnare 1000 cerchi o 10.000 cerchi? Sarà piuttosto problematico se usiamo questo metodo tradizionale per costruire queste variabili e nominarle. Non dobbiamo imparare un nuovo metodo di compilazione delle variabili. Ecco un metodo flessibile che può aiutarci a raggiungere questo obiettivo. Questo è usare randomSeed. Ora, diamo un'occhiata al suo effetto dopo essere stato utilizzato. Esempio di codice (5-6):[cceN_cpp theme="dawn"] void setup(){ size(700, 700); sfondo(0);noStroke();}

4. disegno vuoto(){

   sfondo(0);

   semecasuale(1);

   for(int i = 0;i < 10;i++){

   float randomWidth = random(20.0, 60.0);

   ellisse(random(larghezza), random(altezza), randomWidth, randomWidth);

   }

   } [/cceN_cpp]

   Rispetto al codice precedente, non ha alcuna modifica se non la modifica dell'intervallo del raggio del cerchio da 10 a oltre 30 con una frase di solo ofSeedRandom. Dopo aver aggiunto questa frase, la grafica sembra diventare statica.

   Richiama formato:

   seme casuale(a);

   In questo formato, l'impostazione di a è seed. Devi inserire un numero intero (scrivi un valore in virgola mobile in P5, non andrà storto ma trattalo come un intero) al suo interno. La funzione di randomSeed è impostare il seme per un valore casuale. Quindi genererà diversi array casuali in base al seme diverso. Dopo di ciò, invochiamo la funzione random in modo che il risultato di return sia definito. Qui, il definito non è per il risultato è un valore definito ma per l'array generato. Vale a dire che il risultato del ritorno è definito rispetto ai tempi di invocazione.

   Esempio di codice (5-7):[cceN_cpp theme="dawn"] void setup(){

   semecasuale(0);

   for(int i = 0;i < 5;i++){

   println(random(10));

   }

   } [/cceN_cpp]

   Ora continuiamo a usare println per fare un esperimento. Dopo aver usato randomSeed, ogni volta che chiudi il programma e lo riavvii, tornerà a una stringa con lo stesso risultato. Il valore corrisponderà alla sequenza uno per uno. Se lo elimini, ogni volta tornerà a un valore diverso. Perché ha questa impostazione? È perché il valore casuale stesso nel programma è pseudo casuale. Il risultato sembra casuale ma in realtà è generato da un metodo di calcolo fisso e ripetibile. È equivalente a designare un valore primitivo per randomSeed, quindi il seguente risultato verrà calcolato in base a questo seme. Tuttavia, se non designiamo il seme, il programma utilizzerà per impostazione predefinita l'ora attuale del sistema per generare il seme. Quindi il risultato di ogni operazione è diverso. L'esempio seguente può aiutarti a capire meglio randomSeed.

   Codice di esempio (5-8):[cceN_cpp theme="dawn"] void setup(){

   dimensione (700, 700);

   sfondo(0);

   noStroke();

   }

   disegno vuoto(){

   semecasuale(1);

   for(int i = 0;i < 10;i++){

   float randomWidth01 = random(10, 60);

   ellisse(random(larghezza), random(altezza), randomWidth01, randomWidth01);

   println(randomWidth01);

   }

   semecasuale(1);

   for(int i = 0;i < 10;i++){

   float randomWidth02 = random(10, 60);

   ellisse(random(larghezza), random(altezza), randomWidth02, randomWidth02);

   println(randomWidth02);

   }

   } [/cceN_cpp]

   Prova a rivedere il secondo randomSeed(1) in randomSeed(0) e confronta i risultati finali.

   Suggerimenti: In P5, dobbiamo solo invocare la funzione noLoop alla fine del disegno in modo da poter ottenere lo stesso effetto. La sua funzione è terminare il programma. È abbastanza diverso dai principi di funzionamento di cui sopra in natura.

Passaggio 5: utilizzare il ciclo per disegnare una linea

Dopo aver imparato l'uso di randomSeed, possiamo provare a cambiare la funzione di disegno. Ad esempio, cambia il disegno del cerchio in un disegno al tratto. Solo se progettiamo alcune regole che cambiano fino alla fine della linea, possiamo usare molte linee intrecciate per creare un modello unico.

Esempio di codice(5-9):

[cceN_cpp theme="alba"] void setup(){

dimensione (700, 700);

sfondo(0);

}

disegno vuoto(){

semecasuale(0);

for(int i = 0; i < 2000; i++){

float x1 = larghezza/2.0;

float x2 = casuale(50.0, 650.0);

corsa (255, 20);

riga(x1, 50, x2, 650);

}

} [/cceN_cpp]

Crea pennello semplice

Torna di nuovo al ciclo for. Gli esempi precedenti non sono interattivi. Se vogliamo che il risultato diventi più interessante, non possiamo dimenticare di combinare mouseX e mouseY nel nostro codice.

Esempio di codice (5-10):

[cceN_cpp theme="alba"] void setup(){

dimensione (700, 700);

sfondo(255);

noStroke();

}

disegno vuoto(){

for(int i = 0;i < 1000;i++){

riempimento(0, 30);

float x = mouseX + random(-50, 50);

float y = mouseY + random(-50, 50);

ellisse(x, y, 2, 2);

}

} [/cceN_cpp]

Viene creato un pennello "punti di dispersione". Poiché ogni mini round intensivo si basa sulla posizione del mouse, può spostarsi in direzioni limitate dalle quattro direzioni di sinistra, destra, su e giù. Quindi la diffusione della forma finale del pennello è simile a un quadrato.

Esempio di codice (5-11):

[cceN_cpp theme="alba"] void setup(){

dimensione (700, 700);

sfondo(255);

noStroke();

}

disegno vuoto(){

for(int i = 0;i < 1000;i++){

rapporto float = mouseX/(float)larghezza;

float x = mouseX + random(-50, 50);

float y = mouseY + random(-50, 50);

fill(0, rapporto * 255, 255 * (1 - rapporto), 30);

ellisse(x, y, 2, 2);

}

}

[/cceN_cpp]

Se usiamo il valore di mouseX per influenzare il colore di riempimento, otterremo un gradiente di colore molto più magico.

Passaggio 6: per loop annidati

For loop può essere nidificato. Puoi scrivere di nuovo un ciclo for nel ciclo for. Quando devi disegnare una matrice di punti bidimensionale, puoi scegliere questo metodo.

Esempio di codice (5-12):

[cceN_cpp theme="alba"] void setup(){

dimensione (700, 700, P2D);

sfondo(202, 240, 107);

}

disegno vuoto(){

riempire (0);

for(int i = 0;i < 5;i++){

for(int j = 0;j < 5;j++){

float x = 150 + i * 100;

float y = 150 + j * 100;

ellisse(x, y, 60, 60);

println(i + ":" + j);

}

}

}

[/cceN_cpp]

Per usare il ciclo annidato per la prima volta, devi capire le sue relazioni logiche. L'implementazione del codice nel programma è sempre dall'alto verso il basso. Pertanto, il primo implementato è sicuramente il ciclo più esterno. Ogni volta che l'anello esterno funziona per una volta, l'anello interno funzionerà continuamente fino a quando non sarà più in grado di soddisfare la condizione. Successivamente, inizierà la seconda operazione di loop esterno. Dopo l'avvio della seconda operazione, il ciclo interno continuerà ad essere implementato fino a quando non sarà più in grado di soddisfare la condizione. Tale ripetizione lo fa fino a quando tutte le condizioni non possono essere soddisfatte e salta fuori dal ciclo.

Nel codice sopra, il corpo del ciclo nel ciclo esterno ha operato 5 volte in totale, mentre il corpo del ciclo nel ciclo interno ha operato 25 volte. Entro 25 volte, in base alla differenza del valore i, j, possiamo assicurare separatamente la coordinata orizzontale e verticale del cerchio. Ho incorporato una sezione di stampa, puoi osservare l'output dei dati e pensare al suo cambiamento. Con solo due cicli annidati, possiamo sperimentare tutte le combinazioni di dati i, j.

Suggerimenti

Il ciclo For nel secondo livello di solito si condensa con Tab all'inizio. Questo può rendere più chiara la struttura del codice. Devi nominare le variabili locali nei due livelli del ciclo for con nomi diversi. Tra questi, "i", "j", "k" è il più comunemente usato.

Uso flessibile "i", "j"

I nomi delle due variabili di "i", "j" rappresentano le variabili locali dei due livelli del ciclo for. L'esempio seguente approfondirà la tua comprensione di "i""j". In base al diverso valore di "i", "j", possiamo inserire parametri per raggruppare gli elementi.

Esempio di codice (5-13):[cceN_cpp theme="dawn"] void setup() {

dimensione (700, 700);

sfondo(0);

noStroke();

}

disegno vuoto() {

sfondo(0);

riempire (250, 233, 77);

for (int i = 0; i < 7; i++) {

for (int j = 0; j < 7; j++) {

pushMatrix();

traduci(50 + i * 100, 50 + j * 100);

// Impostazione 1

//angolo flottante = sin(millis() / 1000,0) * PI/2;

// Impostazione 2

//rapporto flottante = i/7.0;

//angolo flottante = sin(millis() / 1000.0 + rapporto * (PI/2)) * PI/2;

// Impostazione 3

rapporto float = (i * 7 + j)/49,0;

angolo float = sin(millis() / 1000.0 + rapporto * (PI/2)) * PI/2;

ruotare (angolo);

rectMode(CENTRO);

// Disegna l'immagine 1

rect(0, 0, 80, 80);

// Disegna l'immagine 2

// rect(0, 0, 100, 20);

// Disegna l'immagine 3

//rect(0, 0, rapporto * 50);

popMatrix();

}

}

} [/cceN_cpp]

Codice Spiegazione

rectMode(CENTER) può cambiare il metodo di disegno del quadrato. I primi due parametri originali di rect vengono utilizzati per definire la coordinata dell'angolo superiore sinistro del quadrato. Dopo aver avviato questo comando, questi due parametri verranno utilizzati per impostare la coordinata per il punto centrale del quadrato. Perché qui operiamo la rotazione del modello attraverso la rotazione, quindi abbiamo bisogno di usare questo metodo per disegnare il punto centrale sul punto originale della coordinata.

millis() acquisisce il tempo dall'inizio del programma al presente. L'unità è ms. Questo valore influenzerà la velocità di variazione del valore di uscita sin. Se scriviamo direttamente millis, la scala che cambia è troppo grande. Quindi, dobbiamo dividerlo per 1000.0.

In questa sezione di codice, utilizziamo il simbolo di commento "//" per nascondere diverse impostazioni. È possibile spostare gli effetti avviando o chiudendo. Ad esempio, se iniziamo le frasi dietro "Setting 3", dobbiamo usare il simbolo di commento per chiudere i blocchi di codice dietro "Setting 1" e "Setting 2". Per quanto riguarda gli esempi di questa struttura di programma simile con diverse variabili locali, possiamo scrivere in questo formato. In questo modo non è necessario archiviare diversi documenti di ingegneria separatamente. Possiamo usare questa abilità spesso durante la pratica e la creazione e preservare alcune impostazioni dei parametri soddisfacenti.

Tra questi, l'influenza del valore i, j sul programma è rappresentata principalmente dallo spostamento di "Impostazione 1 (Impostazione 2)(Impostazione 3)". Puoi confrontare i risultati di output di seguito.

Disegna l'immagine 1: Impostazione 1

Disegna l'immagine 1: Impostazione 2

Disegna l'immagine 1: Impostazione 3

Disegna l'immagine 2: Impostazione 1

Disegna l'immagine 2: Impostazione 2

Disegna l'immagine 2: Impostazione 3

Nell'impostazione 1, non abbiamo usato i e j per influenzare l'angolo di rotazione di ciascun elemento. Quindi possiamo vedere che il movimento di ogni elemento è lo stesso. Mentre nell'impostazione 2, abbiamo usato il valore i e sia i che j nell'impostazione 3. Infine hanno influenzato l'input del parametro della funzione sin through ratio. Questo ha cambiato il cambio periodico dell'angolo. Poiché l'effetto reale dell'impostazione 2 e dell'impostazione 3 non è così ovvio nella grafica animata, possiamo osservarlo dallo screenshot seguente.

Disegna l'immagine 2 (sinistra: impostazione 2; destra: impostazione 3)

Disegna l'immagine 3 (sinistra: impostazione 2; destra: impostazione 3)

Nella prima immagine, il rapporto viene utilizzato per influenzare l'angolo di rotazione quadrato. Mentre la seconda immagine, serve per controllare direttamente il raggio del cerchio. Possiamo vedere che ha usato i value frase:

rapporto float = i/7.0;

Il suo cambiamento di elemento verticale è coerente. Poiché la coordinata orizzontale per il controllo dell'immagine dipende solo dal valore di i, quindi i modelli con la stessa coordinata orizzontale saranno gli stessi. E anche il valore di rapporto, angolo di rotazione e raggio del cerchio è lo stesso.

Allo stesso tempo, usiamo i, j frase:

rapporto float = (i * 7 + j)/49,0;

Può descrivere "gradiente". Qui, con il metodo della moltiplicazione di un fattore, ha combinato l'influenza di righe e colonne. Quindi ogni elemento è diverso.

Passaggio 7: durante il ciclo

C'è un fratello per il ciclo for. Questo è il ciclo while. Cosa può fare for loop, lo può fare anche loop. Ma la frequenza di utilizzo del ciclo while in creativeCoding non è elevata come per il ciclo.

Esempio di codice (5-14):[cceN_cpp theme="dawn"] void setup(){

int a = 0;

mentre(a < 10){

println(a);

a++;

}

} [/cceN_cpp]

La struttura grammaticale di while è più facile da capire che per. Possiamo creare variabili prima dell'istruzione while. Quindi inserisci un'espressione tra parentesi quadre. Quando è soddisfatto, aziona le frasi all'interno del corpo del ciclo. Infine inseriamo un'espressione nel corpo del ciclo per aggiornare le variabili, quindi mentre il ciclo è terminato. Per quanto riguarda i tempi di loop assicurati, usiamo spesso for loop. Per quanto riguarda il valore della variabile infinita, ti consigliamo di utilizzare while loop.

Pensare:

Prova a utilizzare tutti i tipi di elementi di base per sostituire gli elementi di disegno nel ciclo for per creare vari pennelli diversi.

Combina con la funzione trigonometrica di cui all'ultimo capitolo, prova a rivedere il pennello "punti di dispersione" in un pennello di forma rotonda.

Prova a creare una matrice di punti bidimensionale solo con un ciclo for.

Prossimo capitolo AnteprimaCome con questo corso, troverai ogni nuova conoscenza che impari, la possibilità di giocare sarà immediatamente aumentata molto. Il programma è un vaso di Pandora. Tutto ciò che puoi immaginare, può farlo per te. Quindi non c'è motivo per non imparare questa lingua che può comunicare con i computer. Nel nostro prossimo capitolo, vi presenteremo un'altra dichiarazione di controllo del processo. Può controllare il flusso del processo e generare risultati più complicati e mutevoli. Con l'istruzione if, puoi creare facilmente i tuoi giochi di avventura testuali! –Metti in funzione la tua immagine (parte prima) Interessante guida alla programmazione per i designer–Metti in funzione la tua immagine (parte seconda)

Passaggio 8: fonte

Questo articolo è tratto da:

In caso di domande, è possibile contattare: [email protected].