1
00:00:04,260 --> 00:00:05,340
‫Ben tornato.

2
00:00:05,700 --> 00:00:11,550
‫Ora abbiamo una modalità di gioco e vorremmo utilizzare la modalità di gioco per determinare quando possiamo iniziare il gioco.

3
00:00:11,580 --> 00:00:17,700
‫Ora, alcuni giochi hanno un ritardo o un conto alla rovescia che inizia all'inizio del gioco.

4
00:00:17,700 --> 00:00:23,460
‫E dopo un determinato periodo di tempo, il giocatore può spostare il personaggio o, nel nostro caso, il carro

5
00:00:23,460 --> 00:00:25,450
‫armato in giro per il mondo.

6
00:00:25,470 --> 00:00:28,500
‫Quindi lo implementeremo in questo video.

7
00:00:28,530 --> 00:00:35,520
‫Ciò comporterà prima la disabilitazione dell'input in modo da non poterci muovere quando il gioco inizia per la prima

8
00:00:35,520 --> 00:00:41,860
‫volta, quindi imposteremo un timer e dopo un determinato periodo di tempo, quindi potremo abilitare l'input.

9
00:00:41,880 --> 00:00:47,870
‫Quindi torniamo a mettere a punto la modalità di gioco dei carri armati e aggiungiamo un paio di cose qui.

10
00:00:47,880 --> 00:00:54,030
‫Per prima cosa, vorrei aggiungere un float per la quantità di tempo che dovrebbe trascorrere all'inizio del gioco prima che

11
00:00:54,030 --> 00:00:55,380
‫possiamo iniziare a muoverci.

12
00:00:55,410 --> 00:01:03,120
‫Quindi questo float verrà chiamato ritardo di avvio e lo inizializzerò su tre punti F in modo che dobbiamo

13
00:01:03,120 --> 00:01:06,800
‫aspettare 3 secondi prima di poter iniziare il gioco.

14
00:01:06,810 --> 00:01:12,420
‫Ora, non appena il gioco inizia, vorrei avviare questo timer, il che significa che vorrei una funzione

15
00:01:12,420 --> 00:01:16,510
‫che avvii questo timer e renderò anche questa una funzione privata.

16
00:01:16,530 --> 00:01:21,180
‫Farò di questa una funzione vuota chiamata handle game start.

17
00:01:21,210 --> 00:01:25,200
‫Ora posso implementare la gestione dell'avvio del gioco nella modalità di gioco dei carri armati.

18
00:01:25,470 --> 00:01:28,320
‫Scendi qui sotto inizia a giocare.

19
00:01:28,770 --> 00:01:36,090
‫Ora non dimenticherò di aggiungere il nome della classe della modalità di gioco dei carri armati qui e ora ho una funzione di avvio del gioco

20
00:01:36,090 --> 00:01:36,930
‫con maniglia.

21
00:01:37,170 --> 00:01:40,410
‫Ora il posto in cui chiamarlo sarebbe Begin Play.

22
00:01:40,620 --> 00:01:43,590
‫Poiché Begin Play viene chiamato all'inizio del gioco.

23
00:01:43,590 --> 00:01:47,180
‫Quindi chiamerò handle game, inizierò da qui e inizierò a giocare.

24
00:01:47,190 --> 00:01:52,110
‫E dal momento che stiamo facendo un paio di cose qui all'inizio del gioco in cui impostare il carro

25
00:01:52,110 --> 00:01:58,050
‫armato e la messa a punto dei carri armati, il giocatore, le variabili del controller, mi piacerebbe spostarle nella gestione dell'avvio del gioco.

26
00:01:58,050 --> 00:02:03,600
‫Quindi sposterò quelli direttamente in handle game start e in questo modo il controller del giocatore tank

27
00:02:03,600 --> 00:02:08,940
‫e tune tank sarà impostato poiché chiameremo handle game start qui e iniziare a giocare.

28
00:02:08,940 --> 00:02:15,990
‫Quindi qui è dove vorrei iniziare un conto alla rovescia dopo il quale possiamo abilitare l'input dell'utente.

29
00:02:15,990 --> 00:02:21,480
‫Ora, prima di avviare il timer, disabiliterò l'input in modo da non poter ancora spostare il serbatoio.

30
00:02:21,690 --> 00:02:24,420
‫E questo richiederà la nostra funzione.

31
00:02:24,420 --> 00:02:29,670
‫Abbiamo posizionato qui in serbatoi di messa a punto, il controller del giocatore chiamato imposta lo stato abilitato del giocatore.

32
00:02:29,670 --> 00:02:33,690
‫E questo significa che userò i carri armati, il controller del giocatore.

33
00:02:33,690 --> 00:02:38,400
‫E se ho intenzione di usare il controller del giocatore di tune tank, è una buona idea assicurarmi che sia valido.

34
00:02:38,400 --> 00:02:46,200
‫Quindi ho intenzione di dire se sintonizzare carri armati, giocatore, controller e se raggiungiamo l'interno

35
00:02:46,200 --> 00:02:57,570
‫di questa dichiarazione if, allora posso prendere sintonizzare carri armati, controller del giocatore e chiamare lo stato abilitato del giocatore e passare in false.

36
00:02:57,690 --> 00:03:00,720
‫E in questo modo il nostro carro armato non potrà muoversi.

37
00:03:00,720 --> 00:03:06,780
‫E vedo gli scarabocchi rossi e questo perché ho detto carri armati, controller del giocatore piuttosto che sintonizzazione dei carri

38
00:03:06,780 --> 00:03:07,380
‫armati.

39
00:03:07,830 --> 00:03:11,250
‫Quindi, scrivendolo correttamente ora non ottengo errori lì.

40
00:03:11,250 --> 00:03:13,690
‫Quindi ora dobbiamo avviare un timer.

41
00:03:13,710 --> 00:03:20,850
‫Ora sappiamo che i timer implicano l'uso di un handle di timer F e possiamo effettivamente creare un handle di timer

42
00:03:20,850 --> 00:03:25,110
‫F piuttosto che avere una variabile membro che appartiene alla classe.

43
00:03:25,200 --> 00:03:31,470
‫Quindi andrò avanti e lo farò e chiamerò questa maniglia del timer di abilitazione del giocatore.

44
00:03:31,800 --> 00:03:38,340
‫E poi, abbiamo bisogno di impostare un timer ora per la funzione di richiamata per il nostro timer, vorrei usare

45
00:03:38,340 --> 00:03:45,390
‫imposta lo stato abilitato del lettore, ma imposta lo stato abilitato del lettore è una funzione che richiede un input di tipo booleano.

46
00:03:45,990 --> 00:03:51,900
‫Ora non abbiamo visto come impostare un timer utilizzando una richiamata che richiede parametri di input.

47
00:03:51,900 --> 00:03:56,190
‫Ciò comporterà un nuovo concetto chiamato delegato timer.

48
00:03:56,190 --> 00:03:59,310
‫Quindi diamo un'occhiata al sistema di timer di Unreal Engine.

49
00:03:59,310 --> 00:04:07,080
‫Ancora una volta, sappiamo che esiste un gestore di timer mondiale che gestisce i nostri timer e ha una funzione timer impostata.

50
00:04:07,170 --> 00:04:11,280
‫Ora ci sono più sovraccarichi della funzione timer impostata.

51
00:04:11,370 --> 00:04:13,410
‫Ne abbiamo già visto uno.

52
00:04:13,440 --> 00:04:16,710
‫Ora parlerò di un'altra versione di questa funzione.

53
00:04:16,710 --> 00:04:24,570
‫E questa versione richiede un handle del timer, una velocità del timer o un tempo di ritardo durante il quale dobbiamo attendere prima che la

54
00:04:24,570 --> 00:04:26,760
‫nostra funzione di callback venga chiamata.

55
00:04:26,760 --> 00:04:32,550
‫E invece di prendere direttamente l'indirizzo di una funzione di callback, può richiedere qualcosa chiamato delegato del

56
00:04:32,550 --> 00:04:33,270
‫timer.

57
00:04:33,270 --> 00:04:40,440
‫Questa è una struttura di delegato timer di tipo F, che ci consente di creare un oggetto che può associare una funzione

58
00:04:40,440 --> 00:04:41,490
‫direttamente ad esso.

59
00:04:41,490 --> 00:04:45,600
‫E i delegati timer possono associare funzioni che richiedono parametri di input.

60
00:04:45,600 --> 00:04:53,370
‫Ora possiamo creare una variabile del delegato del timer EF e inizializzarla usando la funzione di creazione dell'oggetto dal

61
00:04:53,370 --> 00:04:55,080
‫delegato del timer f.

62
00:04:55,110 --> 00:05:00,990
‫Questo creerà un nuovo delegato timer e lo inizializzerà in base a ciò che passiamo tra parentesi.

63
00:05:00,990 --> 00:05:03,810
‫Ciò richiederà un oggetto utente che è di.

64
00:05:03,860 --> 00:05:08,110
‫Naturalmente, la classe su cui esiste la nostra funzione di callback.

65
00:05:08,120 --> 00:05:15,110
‫E poi prende l'indirizzo della funzione di callback stessa, seguito da tutti i valori di input che vorremmo passare

66
00:05:15,110 --> 00:05:18,450
‫al nostro callback una volta che viene chiamato.

67
00:05:18,470 --> 00:05:24,830
‫Da lì possiamo chiamare set timer dal world timer manager e utilizzare il sovraccarico che richiede un delegato

68
00:05:24,830 --> 00:05:25,450
‫timer.

69
00:05:25,460 --> 00:05:32,300
‫Questo sovraccarico richiede lo stesso handle del timer, il delegato del timer, la frequenza di riproduzione o un float che determina il

70
00:05:32,300 --> 00:05:38,630
‫ritardo prima del quale verrà chiamata la nostra callback, e quindi un valore booleano per determinare se il nostro timer deve

71
00:05:38,630 --> 00:05:43,310
‫essere eseguito in loop, in modo da sapere come creare un Delegato temporizzatore F.

72
00:05:43,310 --> 00:05:49,610
‫Quindi vorrei che ne creassi uno nella funzione handle game start all'interno della nostra nuova istruzione if.

73
00:05:49,610 --> 00:05:54,200
‫Quindi crea un delegato del timer f locale e usa il delegato del timer f.

74
00:05:54,200 --> 00:05:55,640
‫Crea il tuo oggetto.

75
00:05:55,640 --> 00:06:01,610
‫Ora avremo bisogno di passare un oggetto utente e di solito lo abbiamo usato come oggetto utente,

76
00:06:01,610 --> 00:06:05,870
‫ma la funzione che vorremmo chiamata esiste sul controller del giocatore.

77
00:06:05,870 --> 00:06:12,320
‫Quindi passa al controller del giocatore di carri armati a sintonizzazione variabile come primo input che sarà l'oggetto utente

78
00:06:12,320 --> 00:06:18,890
‫e la funzione di callback verrà impostata sullo stato abilitato del giocatore quella funzione che abbiamo aggiunto al nostro controller

79
00:06:18,890 --> 00:06:20,300
‫del giocatore personalizzato.

80
00:06:20,300 --> 00:06:25,730
‫Non dimenticare l'indirizzo dell'operatore e come terzo input passeremo il valore.

81
00:06:25,730 --> 00:06:32,330
‫È vero, questo è ciò che verrà passato allo stato impostato per il giocatore abilitato quando il nostro callback verrà chiamato

82
00:06:32,330 --> 00:06:33,590
‫alla fine del timer.

83
00:06:33,590 --> 00:06:36,710
‫Quindi metti in pausa il video e provalo ora.

84
00:06:39,560 --> 00:06:46,580
‫Quindi, appena sotto il nostro handle del timer, creerò un delegato del timer F locale e

85
00:06:46,580 --> 00:06:50,540
‫chiamerò questo delegato del timer di abilitazione del giocatore.

86
00:06:51,140 --> 00:06:51,710
‫Va bene.

87
00:06:51,710 --> 00:06:53,030
‫Se l'hai chiamato qualcos'altro.

88
00:06:53,030 --> 00:07:00,200
‫Ora lo inizializzerò usando f timer, delegherò, creerò il tuo oggetto.

89
00:07:00,470 --> 00:07:06,590
‫E questo richiederà prima un oggetto utente e quello sarà il nostro controller del giocatore di carri armati.

90
00:07:06,590 --> 00:07:11,300
‫Quindi dirò sintonizza il controller del giocatore dei carri armati come primo input.

91
00:07:11,390 --> 00:07:19,250
‫E per il secondo abbiamo bisogno della nostra funzione di richiamata e quella sarà un giocatore di carri armati, lo

92
00:07:19,910 --> 00:07:23,360
‫stato abilitato del giocatore del set di controller.

93
00:07:23,360 --> 00:07:30,290
‫E non posso dimenticare, ho bisogno dell'indirizzo dell'operatore per questo indirizzo di funzione e il valore che vorrei

94
00:07:30,290 --> 00:07:34,670
‫passato a questa funzione di callback sarà vero in questo modo.

95
00:07:34,670 --> 00:07:41,120
‫Alla fine del tempo di ritardo, quando questo callback viene chiamato true sarà il valore passato alla

96
00:07:41,120 --> 00:07:42,290
‫funzione di callback.

97
00:07:42,290 --> 00:07:48,770
‫Ora sono pronto per chiamare il timer impostato, il che significa che devo chiamare get world timer manager.

98
00:07:48,950 --> 00:07:51,530
‫E poi da lì posso chiamare il timer impostato.

99
00:07:52,070 --> 00:07:59,030
‫E il sovraccarico della funzione che stiamo usando per primo prende un handle del timer e quello sarà un handle del timer

100
00:07:59,060 --> 00:08:00,560
‫di abilitazione del giocatore.

101
00:08:00,590 --> 00:08:04,370
‫Il prossimo input che passerò sarà il delegato.

102
00:08:04,370 --> 00:08:08,630
‫Quindi sarà abilitato al giocatore, delegato del timer.

103
00:08:10,130 --> 00:08:10,520
‫Prossimo.

104
00:08:10,520 --> 00:08:16,700
‫Abbiamo bisogno del nostro tempo di ritardo e questo sarà il ritardo di inizio, che è il galleggiante che abbiamo appena creato.

105
00:08:16,730 --> 00:08:20,120
‫Quindi il prossimo passo è in ritardo di avvio.

106
00:08:20,990 --> 00:08:27,590
‫E infine, non voglio che questo timer si ripeta, quindi passerò false in modo da non ottenere un comportamento

107
00:08:27,590 --> 00:08:28,430
‫in loop.

108
00:08:29,300 --> 00:08:33,020
‫Ora vado avanti e indenta questi input in modo che sembri carino.

109
00:08:33,710 --> 00:08:38,690
‫E ora chiamiamo il timer impostato utilizzando il nostro nuovo delegato timer.

110
00:08:38,690 --> 00:08:45,380
‫E alla fine di questo tempo di ritardo dovremmo ottenere la nostra funzione di callback imposta lo stato abilitato del lettore chiamato con

111
00:08:45,380 --> 00:08:51,440
‫il valore true passato ora poiché il ritardo di avvio è di 3 secondi e stiamo chiamando lo stato abilitato del

112
00:08:51,440 --> 00:08:55,190
‫lettore impostato che passa in falso prima di impostare il nostro timer.

113
00:08:55,190 --> 00:09:00,920
‫Quando premiamo play, non dovremmo essere in grado di muoverci fino a quando questo ritardo di tre secondi non è scaduto.

114
00:09:00,920 --> 00:09:03,590
‫Quindi compiliamo questo e vediamo come funziona.

115
00:09:04,100 --> 00:09:09,140
‫Quindi vado avanti e premo play e provo a muovermi e non ci riesco.

116
00:09:09,140 --> 00:09:12,470
‫E dopo 3 secondi posso improvvisamente muovermi.

117
00:09:12,500 --> 00:09:14,210
‫E controlla anche questo.

118
00:09:14,240 --> 00:09:17,330
‫Si noti che il mio cursore è il mirino.

119
00:09:17,330 --> 00:09:23,000
‫Potrebbe essere difficile da vedere sullo schermo, ma dovresti riuscire a vederlo bene sullo schermo.

120
00:09:23,000 --> 00:09:27,470
‫E questo mi rende molto più facile mirare e controllare i miei carri armati.

121
00:09:27,470 --> 00:09:28,820
‫Rotazione della torretta.

122
00:09:29,210 --> 00:09:30,140
‫Perfetto.

123
00:09:30,140 --> 00:09:36,440
‫Quindi, in sintesi, abbiamo creato una funzione di avvio del gioco handle per la modalità di gioco e la chiamiamo e

124
00:09:36,440 --> 00:09:37,370
‫iniziamo a giocare.

125
00:09:37,580 --> 00:09:45,830
‫E abbiamo anche impostato un timer utilizzando un delegato timer su cui abbiamo associato la nostra funzione di stato abilitato per il giocatore impostato sul

126
00:09:45,830 --> 00:09:47,180
‫controller del giocatore.

127
00:09:47,180 --> 00:09:53,810
‫Questo ci ha permesso di avere una funzione di callback per il nostro timer che accetta i parametri di input e lo

128
00:09:53,810 --> 00:09:58,340
‫usiamo per abilitare l'input dell'utente dopo un ritardo di tre secondi all'avvio del gioco.

129
00:09:58,370 --> 00:10:03,470
‫Ora, questo potrebbe essere frustrante per un giocatore se non avesse una sorta di segnale visivo, una sorta di

130
00:10:03,470 --> 00:10:05,690
‫fargli sapere che l'input non è abilitato.

131
00:10:05,690 --> 00:10:08,150
‫Qualcosa come un conto alla rovescia sullo schermo.

132
00:10:08,150 --> 00:10:10,640
‫Quindi ce ne occuperemo nei prossimi video.

133
00:10:10,640 --> 00:10:12,410
‫Ma per ora, congratulazioni.

134
00:10:12,410 --> 00:10:18,170
‫Ora sai come associare una funzione che accetta parametri di input a un delegato timer.

135
00:10:18,170 --> 00:10:19,640
‫Ci vediamo nel prossimo video.