1
00:00:04,380 --> 00:00:05,280
‫Ciao e Benvenuto.

2
00:00:05,280 --> 00:00:12,510
‫In questa lezione, accederemo agli attori sovrapposti in qualcosa chiamato array in modo

3
00:00:12,510 --> 00:00:19,800
‫da poter stampare gli attori che vediamo all'interno di questo volume interamente da C++.

4
00:00:19,800 --> 00:00:21,300
‫Entriamo e vediamo come è fatto.

5
00:00:22,480 --> 00:00:30,700
‫Quindi, come nelle precedenti analogie, immaginiamo che un tipo o una variabile sia una casella in cui mettiamo un valore.

6
00:00:31,150 --> 00:00:35,250
‫Ora, cosa succede se non sappiamo quanti valori vogliamo memorizzare?

7
00:00:35,260 --> 00:00:36,640
‫Potremmo creare molte variabili.

8
00:00:36,640 --> 00:00:39,430
‫Se sapessimo che ne avremmo cinque, potremmo fare cinque variabili.

9
00:00:39,700 --> 00:00:45,670
‫Ma cosa accadrebbe se avessimo qualcosa che è imprevedibilmente molti, come il numero di attori che abbiamo nel nostro

10
00:00:46,170 --> 00:00:51,010
‫livello A, o gli attori che si sovrappongono con un particolare volume di innesco?

11
00:00:51,490 --> 00:01:00,130
‫In questo caso, dobbiamo usare un nuovo tipo di dati chiamato array T in Unreal e fondamentalmente un array T di un

12
00:01:00,130 --> 00:01:01,200
‫certo tipo.

13
00:01:01,210 --> 00:01:08,560
‫Anche in questo caso, stiamo vedendo queste parentesi angolari che, come abbiamo detto, in precedenza, compilano i parametri del tempo.

14
00:01:08,980 --> 00:01:14,770
‫E questa volta prendiamo in considerazione, ancora una volta, un tipo che ci dice quale tipo possiamo memorizzare un array.

15
00:01:14,770 --> 00:01:21,310
‫Un array è come una variabile, tranne per il fatto che ha più caselle e il numero di caselle che abbiamo

16
00:01:21,670 --> 00:01:22,750
‫può essere diverso.

17
00:01:22,750 --> 00:01:23,920
‫Quando stiamo giocando.

18
00:01:23,920 --> 00:01:24,910
‫Può cambiare.

19
00:01:24,910 --> 00:01:30,880
‫Possiamo aggiungere più o meno mentre procediamo nel gioco, poiché le cose iniziano a sovrapporsi con l'aggiunta di più caselle, mentre le

20
00:01:30,880 --> 00:01:33,640
‫cose lasciano la zona di sovrapposizione, le portiamo via.

21
00:01:33,880 --> 00:01:37,270
‫E come ho detto, questo è un parametro all'interno di questi.

22
00:01:38,270 --> 00:01:39,260
‫Parentesi angolari.

23
00:01:39,680 --> 00:01:45,350
‫E quindi potremmo avere una matrice T di int, ad esempio, che memorizzerebbe interi diversi in quelle

24
00:01:45,350 --> 00:01:45,980
‫caselle.

25
00:01:46,310 --> 00:01:52,670
‫Potremmo avere una vasta gamma di puntatori degli attori, e questo in realtà memorizzerebbe i puntatori nelle scatole,

26
00:01:52,670 --> 00:01:55,610
‫il che indicherebbe gli attori nel mondo.

27
00:01:55,940 --> 00:02:01,190
‫E come puoi vedere, potrebbero anche sovrapporsi in modo che alcuni di questi suggerimenti puntino agli stessi attori.

28
00:02:01,490 --> 00:02:04,580
‫Ora pratica che non sarebbe molto utile, ma è certamente possibile.

29
00:02:04,850 --> 00:02:10,790
‫Quindi voglio rivisitare la documentazione del tuo componente primitivo, perché quello che

30
00:02:10,790 --> 00:02:16,450
‫sto cercando qui è una funzione chiamata ottenere attori sovrapposti.

31
00:02:16,460 --> 00:02:20,930
‫E se dai un'occhiata alla funzione Ottieni attori sovrapposti, ce ne sono un paio di versioni.

32
00:02:21,590 --> 00:02:26,570
‫Ma quello che mi interessa di più è il secondo.

33
00:02:27,200 --> 00:02:29,030
‫Non ha un valore di ritorno.

34
00:02:29,030 --> 00:02:30,440
‫È un valore di ritorno nullo.

35
00:02:30,440 --> 00:02:38,690
‫Ma puoi vedere che il primo parametro qui è un array di puntatori attore con una e commerciale alla fine, il

36
00:02:38,690 --> 00:02:43,640
‫che significa che tutto questo è un riferimento a un array t.

37
00:02:43,640 --> 00:02:46,280
‫Ora nota che non è un riferimento costante.

38
00:02:46,700 --> 00:02:51,860
‫Quindi possiamo presumere che questo parametro sia effettivamente un parametro out.

39
00:02:51,860 --> 00:03:00,050
‫Ci fornisce il risultato degli attori sovrapposti e ci dice quali attori si stanno attualmente sovrapponendo alle

40
00:03:00,290 --> 00:03:02,270
‫nostre componenti primitive.

41
00:03:02,540 --> 00:03:06,500
‫Ora capita che il nostro componente box sia un componente primitivo.

42
00:03:06,890 --> 00:03:12,440
‫Quindi il nostro componente trigger è anche componente del progetto e avrei accesso a questa funzione.

43
00:03:13,490 --> 00:03:18,140
‫C'è un secondo argomento qui, ma non dobbiamo preoccuparcene perché in realtà ha un valore

44
00:03:18,140 --> 00:03:19,520
‫predefinito se lo usiamo.

45
00:03:19,730 --> 00:03:25,820
‫Quindi andiamo avanti e proviamo a recuperare e popolare una matrice t di puntatori attivi.

46
00:03:26,150 --> 00:03:28,490
‫Entreremo nel componente del trucco, CPP.

47
00:03:28,520 --> 00:03:31,340
‫Andremo giù ai componenti della zecca.

48
00:03:31,820 --> 00:03:38,150
‫E qui creeremo un array t vuoto che possiamo popolare usando questa funzione.

49
00:03:38,300 --> 00:03:48,080
‫Quindi è la sintassi è t array aprire parentesi angolari una star attore per dire che abbiamo un array t di puntatori attore,

50
00:03:48,080 --> 00:03:55,070
‫chiudere le parentesi angolari e quindi possiamo dare a questa variabile il nome come attori.

51
00:03:55,370 --> 00:04:05,510
‫Quindi chiamiamo per ottenere attori sovrapposti e passiamo alla schiera degli attori.

52
00:04:06,650 --> 00:04:06,890
‫Adesso.

53
00:04:06,890 --> 00:04:11,630
‫Non so perché non lo passano semplicemente come valore di ritorno, ma.

54
00:04:12,780 --> 00:04:13,380
‫Ecco qua.

55
00:04:13,380 --> 00:04:18,150
‫Ci dà l'opportunità di usare quei nostri parametri un po' di più.

56
00:04:18,330 --> 00:04:19,470
‫Ora, va tutto bene.

57
00:04:19,500 --> 00:04:22,110
‫Abbiamo degli attori in una serie.

58
00:04:22,650 --> 00:04:24,090
‫C'è una lunghezza variabile di loro.

59
00:04:24,090 --> 00:04:25,080
‫Potrebbero essercene parecchi.

60
00:04:25,080 --> 00:04:26,310
‫Potrebbe esserci zero.

61
00:04:26,820 --> 00:04:29,490
‫Cosa facciamo con array come questo?

62
00:04:29,640 --> 00:04:33,980
‫Bene, possiamo interrogare quanti elementi ci sono nell'array.

63
00:04:33,990 --> 00:04:40,980
‫Puoi usare le parentesi num punto dell'array e questo può restituire un numero intero che ti dice quanti elementi ci sono

64
00:04:40,980 --> 00:04:41,550
‫nell'array.

65
00:04:41,580 --> 00:04:48,570
‫Quindi in questo particolare array potremmo dire che ce ne sono cinque, e quindi possiamo accedere agli elementi

66
00:04:48,570 --> 00:04:51,780
‫all'interno di quell'array usando queste parentesi quadre.

67
00:04:52,410 --> 00:04:55,830
‫E poi il numero che passi tra parentesi quadre ti dice quale articolo prendere.

68
00:04:56,250 --> 00:05:02,610
‫Ed è una convenzione consueta in molti linguaggi di programmazione che iniziamo a contare da zero negli array.

69
00:05:02,940 --> 00:05:09,480
‫Quindi l'elemento zero di un array è il primo, l'elemento di un array è il secondo, ecc.

70
00:05:09,690 --> 00:05:14,940
‫E così finisci con l'ultimo elemento che è sempre uno in meno rispetto al numero di elementi nell'array.

71
00:05:15,750 --> 00:05:17,490
‫Allora come possiamo usare questa conoscenza?

72
00:05:17,550 --> 00:05:24,330
‫Bene, ad esempio, potremmo stampare gli attori sovrapposti solo se ce n'è più di uno.

73
00:05:24,690 --> 00:05:26,030
‫Quindi come lo faremmo?

74
00:05:26,040 --> 00:05:38,070
‫Vorremmo inserire un'istruzione if dicendo che se il punto num parentesi degli attori è maggiore di zero, allora possiamo fare qualcosa qui, come ottenere

75
00:05:38,070 --> 00:05:46,470
‫l'accesso all'elemento zero dei nostri attori perché sappiamo che se è maggiore di zero, ci deve essere

76
00:05:46,470 --> 00:05:50,100
‫a almeno un elemento lì dentro.

77
00:05:50,100 --> 00:05:54,480
‫Quindi gli elementi zero di questo array devono contenere qualcosa.

78
00:05:54,720 --> 00:05:59,880
‫Non possiamo garantire che il primo elemento, l'unico elemento dell'array contenga qualcosa o che i

79
00:05:59,880 --> 00:06:01,440
‫due elementi contengano qualcosa.

80
00:06:01,680 --> 00:06:06,840
‫Dovremmo controllare se abbiamo abbastanza elementi nell'array per farlo, ma sappiamo sicuramente che

81
00:06:06,840 --> 00:06:08,550
‫qui c'è il primo.

82
00:06:08,730 --> 00:06:12,510
‫Quindi ti sfidiamo a stampare il primo attore sovrapposto da quella matrice.

83
00:06:12,780 --> 00:06:16,470
‫Usa l'array per ottenere il puntatore usando quelle parentesi quadre.

84
00:06:16,770 --> 00:06:22,200
‫Quindi utilizzerai quel puntatore per chiamare, ottenere attore, nome o etichetta, e poi

85
00:06:22,200 --> 00:06:23,280
‫lo stamperai.

86
00:06:23,580 --> 00:06:24,870
‫Metti in pausa il video e prova.

87
00:06:28,250 --> 00:06:28,570
‫Bene.

88
00:06:28,580 --> 00:06:29,390
‫Ben tornato.

89
00:06:29,750 --> 00:06:34,460
‫Quindi possiamo ottenere il puntatore qui usando queste parentesi quadre.

90
00:06:34,820 --> 00:06:41,090
‫E poi prenderò direttamente il nome usando l'operatore freccia e chiamando get attore,

91
00:06:41,240 --> 00:06:43,310
‫nome o etichetta.

92
00:06:44,180 --> 00:06:50,030
‫E lo metterò in una variabile stringa F chiamata nome attore.

93
00:06:50,240 --> 00:06:56,480
‫Quindi faremo un registro U, che chiameremo i due punti sovrapposti.

94
00:06:56,480 --> 00:06:58,130
‫E poi per cento s.

95
00:06:58,460 --> 00:07:03,440
‫E poi il secondo argomento qui dovrebbe essere l'asterisco, il nome dell'attore.

96
00:07:03,740 --> 00:07:09,470
‫Quindi possiamo ricompilare, saltare nel nostro docket del registro di output nel layout.

97
00:07:09,620 --> 00:07:16,070
‫Quindi apriremo il muro segreto della BP perché non voglio stampare questa stringa che confonde

98
00:07:16,070 --> 00:07:17,210
‫le cose.

99
00:07:17,210 --> 00:07:23,960
‫In Blueprint, lo stiamo facendo ora da C++, quindi andiamo al gioco di successo a livello di dungeon.

100
00:07:25,190 --> 00:07:28,430
‫E ovviamente nulla si sta sovrapponendo a quell'attore in questo momento.

101
00:07:28,820 --> 00:07:31,520
‫Quindi cosa succede se entriamo ed entriamo?

102
00:07:32,060 --> 00:07:36,080
‫Puoi vedere che inizia immediatamente a stampare, che stiamo sovrapponendo il lettore BP.

103
00:07:36,500 --> 00:07:37,520
‫Roba fantastica.

104
00:07:37,820 --> 00:07:40,130
‫E se invece dovessimo andare a prendere il gargoyle?

105
00:07:40,370 --> 00:07:43,780
‫Portalo nell'alcova, mettilo dentro e il gioco è fatto.

106
00:07:43,790 --> 00:07:46,160
‫Dice che si sta sovrapponendo alla statua del gargoyle.

107
00:07:46,700 --> 00:07:47,210
‫Roba fantastica.

108
00:07:47,210 --> 00:07:55,280
‫Quindi abbiamo imparato come usare un array t per ottenere un elenco di attori e per scoprire quante cose

109
00:07:55,280 --> 00:08:00,770
‫ci sono in quell'elenco e come ottenere un particolare elemento da quell'elenco.

110
00:08:01,070 --> 00:08:05,600
‫Nella prossima lezione, esamineremo alcune strutture di programmazione che ci consentono di

111
00:08:05,810 --> 00:08:10,520
‫gestire un numero variabile di cose per svolgere un numero variabile di attività.

112
00:08:10,790 --> 00:08:11,600
‫Ci vediamo lì.