﻿1
00:00:04,390 --> 00:00:05,830
‫Ciao e benvenuto a questa lezione.

2
00:00:05,830 --> 00:00:12,880
‫Impareremo come eseguire un pezzo di codice un numero variabile di volte in modo da

3
00:00:12,880 --> 00:00:19,840
‫poter stampare ogni oggetto che si sovrappone all'interno di quest'area, questo componente trigger.

4
00:00:20,080 --> 00:00:24,190
‫Quindi puoi vedere qui che quando siamo entrambi, io sono dentro e c'è anche un gargoyle.

5
00:00:24,460 --> 00:00:29,140
‫Sta stampando sia il nome dei gargoyle che il nome dei progetti del giocatore.

6
00:00:29,440 --> 00:00:31,090
‫Immergiamoci e vediamo come è fatto.

7
00:00:32,020 --> 00:00:38,830
‫Ora, il problema con il nostro codice qui è che il nostro array di attori può avere molto più di un

8
00:00:38,830 --> 00:00:44,020
‫solo attore e se vogliamo che mostri tutti gli attori sovrapposti, vogliamo fare qualcosa con tutti

9
00:00:44,020 --> 00:00:44,800
‫quegli attori.

10
00:00:45,160 --> 00:00:47,650
‫Dobbiamo essere in grado di eseguire il codice.

11
00:00:47,650 --> 00:00:53,680
‫Sarebbe altamente inefficiente scrivere una dichiarazione if per il caso in cui ne abbiamo due o

12
00:00:53,680 --> 00:00:58,780
‫tre o quattro o cinque, ecc. E certamente non prenderebbe mai tutti i casi perché abbiamo un numero limitato

13
00:00:58,780 --> 00:01:00,010
‫di righe nel nostro file.

14
00:01:00,640 --> 00:01:08,620
‫Quindi il modo in cui affrontiamo questo problema, vogliamo ripetere un pezzo di codice più volte, ma un numero di volte che in

15
00:01:08,620 --> 00:01:09,850
‫realtà non sappiamo.

16
00:01:09,850 --> 00:01:15,610
‫Quando stiamo compilando il codice, dobbiamo sostituire la nostra istruzione if, dove l'istruzione if dice essenzialmente,

17
00:01:15,610 --> 00:01:21,490
‫dovrei eseguire questo codice o meno con qualcosa che dice, dovrei eseguire questo codice o dovrei eseguirlo

18
00:01:21,490 --> 00:01:25,090
‫molte volte, due volte, tre volte, quattro volte, ecc.?

19
00:01:25,570 --> 00:01:29,230
‫Il modo in cui lo facciamo è con qualcosa chiamato dichiarazione selvaggia.

20
00:01:29,530 --> 00:01:32,380
‫Ora è costruito in modo molto simile a un'istruzione if.

21
00:01:32,380 --> 00:01:41,230
‫Quindi nel frattempo metti una sorta di valore booleano tra parentesi, e poi abbiamo delle parentesi graffe e all'interno

22
00:01:41,290 --> 00:01:47,650
‫delle parentesi graffe, un blocco di codice che continuerà a essere eseguito

23
00:01:47,650 --> 00:01:54,310
‫ancora e ancora finché la condizione nella nostra istruzione jolly non diventa falsa .

24
00:01:54,310 --> 00:01:55,960
‫Ecco perché si chiama mentre.

25
00:01:55,960 --> 00:01:59,260
‫Quindi, mentre questa cosa è vera, esegui questo codice.

26
00:01:59,260 --> 00:02:04,570
‫Quindi è un po' come un'istruzione if in quanto a volte potrebbe non eseguire affatto il codice,

27
00:02:04,570 --> 00:02:09,910
‫ma a differenza della sua istruzione che può eseguire un pezzo di codice solo una volta, l'istruzione wild

28
00:02:09,910 --> 00:02:14,620
‫potrebbe praticamente continuare a eseguirla per sempre se questo booleano non diventa mai falso.

29
00:02:15,550 --> 00:02:16,990
‫Allora perché è utile?

30
00:02:16,990 --> 00:02:22,180
‫Bene, potremmo creare un int 32 e chiamarlo index e iniziarlo da zero.

31
00:02:22,990 --> 00:02:31,690
‫E poi ogni volta che attraversiamo il corpo di questo ciclo selvaggio, aumentiamo il valore memorizzato in quell'indice.

32
00:02:31,690 --> 00:02:35,830
‫Quindi potremmo dire che indice è uguale a indice più uno.

33
00:02:36,700 --> 00:02:42,460
‫Ora in C++, c'è una scorciatoia per farlo invece di dover fare index più uno in

34
00:02:42,460 --> 00:02:49,210
‫questo modo, fai più più indice e questo aggiunge solo uno a tutto ciò che è memorizzato nella variabile index.

35
00:02:50,050 --> 00:02:50,440
‫Bene.

36
00:02:50,440 --> 00:02:51,910
‫Quindi partiamo da zero.

37
00:02:52,210 --> 00:02:54,700
‫Noi ogni volta che giriamo, aumentiamo l'indice.

38
00:02:55,060 --> 00:03:03,160
‫E quello che possiamo fare è farlo in modo da aggirare questo ciclo selvaggio solo mentre il nostro indice è entro

39
00:03:03,160 --> 00:03:05,170
‫i limiti del nostro array.

40
00:03:05,200 --> 00:03:11,220
‫Quindi possiamo dire che l'indice deve essere inferiore al punto num degli attori.

41
00:03:11,410 --> 00:03:13,210
‫Quindi questa è la dimensione dell'array.

42
00:03:13,210 --> 00:03:19,300
‫Ricorda che quando abbiamo cinque elementi nell'array, l'ultimo elemento nell'array è l'indice quattro.

43
00:03:19,930 --> 00:03:28,210
‫E quindi possiamo vedere che questo sarà vero quando l'indice è valido, quando l'indice quattro è inferiore a cinque.

44
00:03:28,570 --> 00:03:34,460
‫Ma non appena quell'indice supera la fine dell'array, quando arriva all'indice cinque, il numero dell'attore non

45
00:03:34,480 --> 00:03:39,040
‫sarà più non sarà più cinque non sarà più inferiore a cinque.

46
00:03:39,310 --> 00:03:44,920
‫Quindi il ciclo while interromperà l'esecuzione e continuerà con il resto della funzione.

47
00:03:45,790 --> 00:03:54,700
‫Quindi ciò significa che ora potremmo prendere il codice che avevamo sopra e riscriverlo, prenderlo, copiarlo, ritagliarlo

48
00:03:54,700 --> 00:03:57,970
‫e incollarlo qui tra un po'.

49
00:03:57,970 --> 00:03:58,210
‫Ciclo continuo.

50
00:03:58,210 --> 00:04:03,460
‫Ma prima di aumentare l'indice, soprattutto, perché quello che faremo è sostituire questo zero

51
00:04:03,460 --> 00:04:08,290
‫in cui stavamo ottenendo l'attore zero, possiamo sostituirlo con l'indice dell'attore.

52
00:04:08,890 --> 00:04:10,120
‫Quindi seguiamo questo.

53
00:04:10,120 --> 00:04:11,680
‫Come funzionerebbe.

54
00:04:12,580 --> 00:04:12,790
‫Bello.

55
00:04:12,790 --> 00:04:15,700
‫Rimuovi la nostra istruzione if perché crea un po' di confusione.

56
00:04:15,970 --> 00:04:19,960
‫Quindi iniziamo il valore nella variabile index sarà zero.

57
00:04:20,590 --> 00:04:26,770
‫Ora immagina di dover agire per mantenere le cose semplici è zero meno di due.

58
00:04:27,160 --> 00:04:28,330
‫Si si lo è.

59
00:04:28,690 --> 00:04:37,450
‫Quindi entriamo e otteniamo l'attore zero, otteniamo il suo nome e lo disconnettiamo e quindi aumentiamo il valore nell'indice

60
00:04:37,450 --> 00:04:38,620
‫di uno.

61
00:04:38,620 --> 00:04:40,570
‫Quindi si passa dall'essere zero all'essere uno.

62
00:04:41,380 --> 00:04:47,200
‫Ora torniamo a valutare la condizione del ciclo while e diciamo uno meno di due?

63
00:04:47,320 --> 00:04:47,950
‫Sì.

64
00:04:48,280 --> 00:04:55,300
‫Possiamo quindi entrare e prendere l'attore uno e poi prenderemo il suo nome e stamperemo il suo nome.

65
00:04:55,600 --> 00:05:02,140
‫Quindi aumentiamo nuovamente l'indice all'indice due e poniamo di nuovo la domanda nel ciclo while dicendo che due

66
00:05:02,350 --> 00:05:03,850
‫sono meno di due?

67
00:05:04,240 --> 00:05:05,710
‫Bene, la risposta è no.

68
00:05:05,950 --> 00:05:11,800
‫Quindi saltiamo il corpo del ciclo while e proseguiamo ed eseguiamo il resto del codice.

69
00:05:12,520 --> 00:05:15,090
‫Quindi è fondamentalmente ciò che vogliamo ottenere.

70
00:05:15,100 --> 00:05:22,930
‫Vogliamo stampare il nome di ogni attore nell'array, ed è quello che farà questo pezzo di

71
00:05:22,930 --> 00:05:23,440
‫codice.

72
00:05:23,680 --> 00:05:26,200
‫Andiamo avanti e compiliamolo e controlliamo che ho ragione.

73
00:05:26,350 --> 00:05:32,980
‫Se andiamo avanti e premiamo play ed entriamo nell'area, puoi vedere che stavamo sovrapponendo solo il giocatore

74
00:05:32,980 --> 00:05:33,400
‫BP.

75
00:05:33,850 --> 00:05:36,070
‫E se andiamo a prendere il nostro gargoyle?

76
00:05:36,310 --> 00:05:41,020
‫Se lo infiliamo solo nel rimbalzo, puoi vedere che ci sovrapponiamo al gargoyle.

77
00:05:41,050 --> 00:05:43,030
‫Ma cosa succede se intervengo anche io?

78
00:05:43,360 --> 00:05:50,040
‫Ora puoi vedere che sta stampando sia quello che si sovrappone al giocatore che il gargoyle tutti nella stessa cornice.

79
00:05:50,050 --> 00:05:52,060
‫Quindi il nostro loop selvaggio sta funzionando.

80
00:05:52,060 --> 00:05:58,390
‫Sta eseguendo un pezzo di codice più volte quando sono presenti più attori nell'array.

81
00:05:58,570 --> 00:06:04,540
‫Ora, poiché questo modello è così comune che abbiamo una sorta di indice e lo aumentiamo ogni volta che

82
00:06:04,540 --> 00:06:05,500
‫seguiamo il ciclo.

83
00:06:05,860 --> 00:06:15,250
‫In realtà c'è una scorciatoia per questo in C++ e se digiti nel codice di Visual Studio, qui c'è un

84
00:06:15,250 --> 00:06:23,850
‫frammento per un ciclo a quattro che puoi espandere e puoi vedere che questa è una struttura generale.

85
00:06:23,860 --> 00:06:25,390
‫Ha qualcosa chiamato taglia T qui.

86
00:06:25,390 --> 00:06:29,200
‫Possiamo semplicemente sostituirlo con INT 32 per i nostri scopi.

87
00:06:29,710 --> 00:06:36,220
‫E essenzialmente ciò che sta dicendo è che ci sono tre affermazioni all'interno delle parentesi del ciclo for.

88
00:06:36,370 --> 00:06:42,940
‫Il primo è equivalente a dove impostiamo la nostra variabile di indice prima del nostro ciclo while.

89
00:06:43,840 --> 00:06:48,820
‫La seconda è la condizione che è equivalente a ciò che mettiamo all'interno del nostro ciclo while.

90
00:06:49,600 --> 00:06:54,460
‫E puoi vedere che potremmo sostituire il conteggio con il punto num degli attori.

91
00:06:54,730 --> 00:07:01,150
‫E poi l'ultimo bit è fondamentalmente il vantaggio in più se lo metti prima o dopo,

92
00:07:01,150 --> 00:07:07,180
‫l'indice non è troppo importante, ma puoi vedere che questo sta aumentando il valore nell'indice.

93
00:07:07,180 --> 00:07:10,810
‫Quindi è equivalente alla linea che mettiamo alla fine del nostro ciclo.

94
00:07:11,560 --> 00:07:17,890
‫Quindi questo riunisce tutto in una riga ciò che dovevamo distribuire su più utilizzando il nostro

95
00:07:17,890 --> 00:07:18,700
‫loop selvaggio.

96
00:07:18,880 --> 00:07:20,320
‫Quindi ecco una semplice sfida per te.

97
00:07:20,320 --> 00:07:23,230
‫Converti il tuo ciclo waah in un ciclo for.

98
00:07:23,530 --> 00:07:30,220
‫Stai per copiare e il corpo del codice cambierà l'indice da quel nome index a I.

99
00:07:30,220 --> 00:07:36,490
‫In genere usiamo l'abbreviazione nei cicli for di I solo un'abbreviazione per index davvero e compiliamo

100
00:07:36,490 --> 00:07:38,560
‫e testiamo i video.

101
00:07:41,800 --> 00:07:42,130
‫Bene.

102
00:07:42,130 --> 00:07:42,700
‫Ben tornato.

103
00:07:42,730 --> 00:07:44,680
‫Quindi questo dovrebbe essere abbastanza semplice.

104
00:07:44,680 --> 00:07:46,810
‫Non vogliamo l'indice più più qui dentro.

105
00:07:47,170 --> 00:07:49,510
‫Quindi taglieremo il resto.

106
00:07:50,100 --> 00:07:54,310
‫Un cambiamento su dove stiamo indicizzando l'array degli attori con la variabile index.

107
00:07:54,310 --> 00:07:56,550
‫Lo cambieremo in IE la variabile.

108
00:07:56,560 --> 00:07:58,420
‫È disponibile solo all'interno di questo ciclo for.

109
00:07:58,420 --> 00:08:04,700
‫Questo è un altro vantaggio rispetto alla sintassi del ciclo completo è che la variabile IE è disponibile

110
00:08:04,960 --> 00:08:10,150
‫solo all'interno del ciclo completo, mentre quando l'abbiamo dichiarata qui nel ciclo while, è

111
00:08:10,150 --> 00:08:16,960
‫disponibile all'esterno, il che inquina gli indici che possiamo utilizzare in seguito in modo da poter eliminare quel loop selvaggio.

112
00:08:16,960 --> 00:08:23,170
‫E puoi vedere che il ciclo completo è molto più condensato e ti abituerai alla sintassi

113
00:08:23,170 --> 00:08:25,090
‫leggermente strana che ha.

114
00:08:25,420 --> 00:08:30,430
‫Andiamo avanti e compiliamo e controlliamo solo che svolga effettivamente lo stesso lavoro.

115
00:08:30,640 --> 00:08:38,020
‫Se vado a prendere il mio gargoyle e arrivo agli attori sovrapposti, puoi vedere che in effetti sta stampando

116
00:08:38,020 --> 00:08:42,010
‫entrambi i nostri attori quando siamo entrambi sovrapposti nell'alcova.

117
00:08:42,100 --> 00:08:42,790
‫Roba fantastica.

118
00:08:42,790 --> 00:08:49,810
‫Quindi in questa lezione abbiamo visto una nuova idea di programmazione, l'idea dei loop, e ci siamo imbattuti in

119
00:08:49,810 --> 00:08:52,960
‫particolare nel ciclo Y e nel ciclo for.

120
00:08:53,200 --> 00:08:54,700
‫Ci vediamo alla prossima lezione.

