1
00:00:04,290 --> 00:00:05,650
‫Hej, witaj z powrotem.

2
00:00:05,670 --> 00:00:09,900
‫W tym filmie zajmujemy się warunkami wygranej i przegranej.

3
00:00:10,320 --> 00:00:14,520
‫To jedna z ostatnich rzeczy, którymi zajmiemy się w tym projekcie gry.

4
00:00:14,550 --> 00:00:16,860
‫Przyjrzyjmy się teraz naszemu planowi sekcji.

5
00:00:16,860 --> 00:00:23,430
‫Teraz już zaznaczyliśmy pierwsze pięć pozycji w naszym planie sekcji, a ostatnie dwa to efekty

6
00:00:23,430 --> 00:00:26,580
‫specjalne oraz warunki wygranej i przegranej.

7
00:00:26,580 --> 00:00:32,250
‫Chciałbym zamienić te ostatnie dwa i zająć się warunkami wygranej i przegranej tylko dlatego, że

8
00:00:32,250 --> 00:00:39,300
‫jest to ostatnia z naszej logiki programowania rozgrywki, a efekty specjalne są kosmetyczne i bardziej przypominają końcowe poprawki, abyśmy

9
00:00:39,300 --> 00:00:42,420
‫mogli poradzić sobie z tymi na samym końcu.

10
00:00:42,420 --> 00:00:48,300
‫W tym filmie stworzymy funkcję zakończenia gry, abyśmy wiedzieli, kiedy gra została

11
00:00:48,300 --> 00:00:49,950
‫wygrana lub przegrana.

12
00:00:49,950 --> 00:00:55,410
‫A żeby wygrać grę, będziemy musieli policzyć liczbę wież na świecie, ponieważ

13
00:00:55,410 --> 00:00:59,730
‫kiedy zniszczymy wszystkie wieże, wiemy, że wygraliśmy grę.

14
00:00:59,730 --> 00:01:05,670
‫A jeśli sam czołg ulegnie zniszczeniu, możemy uznać to za stan utraty.

15
00:01:05,670 --> 00:01:11,760
‫Wróciłem więc do trybu gry i pierwszą rzeczą, którą chciałbym zrobić, to stworzyć kolejne wydarzenie, które można wdrożyć

16
00:01:11,760 --> 00:01:12,540
‫do planu.

17
00:01:12,570 --> 00:01:19,980
‫Mamy funkcję startu gry, którą możemy wywołać z C++, ale jej logikę implementujemy w trybie

18
00:01:19,980 --> 00:01:20,520
‫gry.

19
00:01:20,520 --> 00:01:27,120
‫Blueprint Dzięki wydarzeniu Blueprint Implementable Event, chciałbym stworzyć kolejny za przegraną

20
00:01:27,120 --> 00:01:27,720
‫grę.

21
00:01:27,720 --> 00:01:31,530
‫Więc mam zamiar stworzyć funkcję void o nazwie Game Over.

22
00:01:31,530 --> 00:01:37,530
‫W tym przypadku chciałbym wziąć boolowski parametr wejściowy o nazwie B one game.

23
00:01:37,530 --> 00:01:43,020
‫I oczywiście będzie to wydarzenie możliwe do zaimplementowania w planie, ponieważ jedyną rzeczą, którą chciałbym

24
00:01:43,020 --> 00:01:50,130
‫obsłużyć za pomocą tej funkcji, jest wyświetlanie, że przegraliśmy lub wygraliśmy grę i że możemy to zrobić na podstawie planów.

25
00:01:50,130 --> 00:01:52,410
‫Mamy więc funkcję „game over”.

26
00:01:52,410 --> 00:01:55,350
‫Teraz musimy wiedzieć, kiedy powinniśmy wywołać tę funkcję.

27
00:01:55,350 --> 00:02:00,450
‫Po pierwsze, wiemy, że możemy wywołać tę funkcję, gdy przegramy grę, a tak

28
00:02:00,450 --> 00:02:02,550
‫się stanie, jeśli czołg zginie.

29
00:02:02,550 --> 00:02:10,050
‫Przejdźmy więc do naszej funkcji śmierci aktora w trybie dostrajania czołgów CP. Widzimy, że jeśli martwy

30
00:02:10,050 --> 00:02:15,840
‫aktor jest czołgiem, to zajmujemy się zniszczeniem czołgu i ustawiamy włączony stan na

31
00:02:15,840 --> 00:02:16,680
‫fałszywy.

32
00:02:16,710 --> 00:02:25,020
‫Inną rzeczą, którą możemy tutaj zrobić, jest zakończenie gry, po prostu wywołując game over, a ta wartość logiczna będzie jedną z gier,

33
00:02:25,020 --> 00:02:27,240
‫którą możemy przekazać jako fałsz.

34
00:02:27,240 --> 00:02:31,770
‫Więc to dba o przegraną, przynajmniej od strony C++.

35
00:02:31,800 --> 00:02:34,770
‫Teraz musimy wiedzieć, kiedy powinniśmy wygrać mecz.

36
00:02:34,800 --> 00:02:36,540
‫Tutaj zmarł aktor.

37
00:02:36,540 --> 00:02:43,050
‫Jeśli martwego aktora można rzucić na wieżę, wiemy, że właśnie zniszczyliśmy wieżę.

38
00:02:43,050 --> 00:02:49,740
‫Byłoby to idealne miejsce do aktualizacji liczby wież lub zmiennej typu integer, która śledzi,

39
00:02:49,740 --> 00:02:53,220
‫ile wież jest obecnie na świecie.

40
00:02:53,250 --> 00:02:53,580
‫Ale już.

41
00:02:53,580 --> 00:02:59,310
‫Aby to zrobić, potrzebujemy zmiennej do śledzenia liczby wież, więc możemy dodać

42
00:02:59,310 --> 00:03:02,250
‫prywatną zmienną tutaj, w pliku H.

43
00:03:02,250 --> 00:03:03,960
‫I chciałbym to zrobić tutaj na dole.

44
00:03:03,960 --> 00:03:08,880
‫Więc mam zamiar utworzyć INT 32 i będę nazywać to docelowymi wieżami.

45
00:03:09,120 --> 00:03:15,840
‫Teraz możemy zainicjować to od razu do wartości zerowej, ale musimy to zaktualizować, gdy

46
00:03:15,840 --> 00:03:17,760
‫liczba wież się zmniejszy.

47
00:03:17,760 --> 00:03:22,350
‫I musimy również ustawić to na liczbę wież na świecie.

48
00:03:22,470 --> 00:03:28,170
‫Teraz moglibyśmy zakodować to na sztywno do czterech, ale co się stanie, gdy zaczniemy dodawać więcej wież do naszych poziomów?

49
00:03:28,170 --> 00:03:30,690
‫Cóż, wtedy sprawa się trochę komplikuje.

50
00:03:30,690 --> 00:03:35,580
‫Chciałbym więc zamiast tego zobaczyć, ile jest wież na świecie.

51
00:03:35,610 --> 00:03:43,050
‫Teraz mógłbym stworzyć dla tego funkcję, która zwraca 32, a ta funkcja może dowiedzieć się, ile jest

52
00:03:43,050 --> 00:03:45,810
‫wież na świecie i zwrócić liczbę.

53
00:03:45,810 --> 00:03:51,450
‫Więc zamierzam wywołać tę funkcję, uzyskać docelową liczbę wież.

54
00:03:51,600 --> 00:03:55,650
‫Więc przejdźmy dalej i nadaj tej funkcji treść w pliku CP.

55
00:03:55,680 --> 00:04:02,130
‫Przejdę na sam dół i stworzę ciało funkcji, nie zapominając o wstawieniu

56
00:04:02,130 --> 00:04:05,040
‫nazwy klasy przed nazwą funkcji.

57
00:04:05,040 --> 00:04:12,270
‫Teraz to zwróci koniec 32 i musimy zdecydować, w jaki sposób dowiemy się, ile jest

58
00:04:12,270 --> 00:04:13,170
‫wież.

59
00:04:13,200 --> 00:04:19,800
‫Teraz w statyce rozgrywki istnieje funkcja o nazwie Pobierz wszystkich aktorów klasy.

60
00:04:19,800 --> 00:04:21,300
‫Oto dokumentacja.

61
00:04:21,300 --> 00:04:25,770
‫Mówi Znajdź wszystkich aktorów w świecie określonej klasy.

62
00:04:25,770 --> 00:04:28,890
‫Musimy więc określić konkretną klasę.

63
00:04:28,920 --> 00:04:31,530
‫Teraz ta funkcja ma trzy wejścia.

64
00:04:31,530 --> 00:04:33,720
‫Pierwszy to obiekt kontekstu światowego.

65
00:04:33,720 --> 00:04:34,770
‫To jest łatwe.

66
00:04:34,770 --> 00:04:36,180
‫Wiemy, jak sobie z tym poradzić.

67
00:04:36,180 --> 00:04:41,610
‫Ale dalej mamy podklasę PT aktora i nazywa się to klasą aktora.

68
00:04:41,610 --> 00:04:48,000
‫Teraz widzieliśmy, że funkcje, które wymagają podklasy PT, mogą akceptować klasę u jako dane wejściowe, a trzecim

69
00:04:48,000 --> 00:04:49,740
‫parametrem jest tablica T.

70
00:04:49,770 --> 00:04:56,940
‫Wymaga tablicy t wskaźników aktora, która jest przekazywana jako referencja i nie jest stałą referencją, która wydaje

71
00:04:56,940 --> 00:05:03,680
‫się sugerować, że ta funkcja może po prostu zmienić ten parametr wejściowy o nazwie act.

72
00:05:03,730 --> 00:05:08,530
‫Oto kolejna wskazówka, że tak właśnie jest, jest to wywołanie aktorów.

73
00:05:08,530 --> 00:05:15,820
‫Jest to parametr out, co oznacza, że przekazujemy go, a następnie po wywołaniu funkcji ma wartości, które zostały

74
00:05:15,820 --> 00:05:18,220
‫w nim wprowadzone przez funkcję.

75
00:05:18,220 --> 00:05:21,340
‫Możemy więc myśleć o tym jako o rodzaju danych wyjściowych dla funkcji.

76
00:05:21,340 --> 00:05:28,810
‫Teraz jest napisane tutaj dla parametrów, klasa aktora to klasa aktora do znalezienia musi być określona lub

77
00:05:28,810 --> 00:05:30,640
‫tablica wyników będzie pusta.

78
00:05:30,640 --> 00:05:37,240
‫Chcemy znaleźć wszystkie wieże, a wyjściowi aktorzy to tablica wyjściowa aktorów określonej klasy.

79
00:05:37,240 --> 00:05:42,670
‫Więc kiedy już wywołamy tę funkcję i przekażemy tablicę, kiedy funkcja się

80
00:05:42,670 --> 00:05:48,160
‫zakończy, ta tablica będzie zawierała wskaźniki do wszystkich aktorów w świecie określonej klasy.

81
00:05:48,160 --> 00:05:51,880
‫Wiemy więc, że ta funkcja wymaga obiektu kontekstu świata.

82
00:05:51,880 --> 00:05:56,500
‫Teraz, jeśli zamierzamy wywołać to z poziomu trybu gry, możemy przejść do tego w następnym.

83
00:05:56,500 --> 00:06:03,490
‫Potrzebujemy podklasy PT określającej aktora A i wiemy, że może to być nowy wskaźnik klasy.

84
00:06:03,490 --> 00:06:06,070
‫Teraz musimy określić klasę do znalezienia.

85
00:06:06,070 --> 00:06:12,010
‫Jeśli określimy aktora, otrzymamy dużą tablicę wypełnioną wskaźnikami do każdego aktora na świecie.

86
00:06:12,010 --> 00:06:13,810
‫Ale nie potrzebujemy wszystkich aktorów.

87
00:06:13,810 --> 00:06:21,070
‫Potrzebujemy tylko wież, abyśmy mogli użyć statycznej klasy wieży, która zwróci nam nową klasę reprezentującą

88
00:06:21,070 --> 00:06:23,290
‫klasę A Tower C++.

89
00:06:23,290 --> 00:06:26,770
‫Teraz trzeci parametr to tablica T wskaźników aktora.

90
00:06:26,770 --> 00:06:33,760
‫Jeśli więc utworzymy zmienną lokalną typu tablica T określająca wskaźnik aktora w nawiasach ostrych, wtedy możemy

91
00:06:33,760 --> 00:06:35,980
‫nazwać cię statystyką gry.

92
00:06:36,010 --> 00:06:41,620
‫Spraw, aby wszyscy aktorzy z klasy przeszli przez te trzy dane wejściowe, a rezultatem tej akcji będzie to,

93
00:06:41,620 --> 00:06:45,970
‫że nasza tablica wież powinna zawierać wskaźniki do wszystkich wież w naszym świecie.

94
00:06:45,970 --> 00:06:52,840
‫Teraz tacka jest ładną klasą kontenera, która może zawierać wiele elementów, o ile wszystkie mają ten

95
00:06:52,840 --> 00:06:53,830
‫sam typ.

96
00:06:53,830 --> 00:07:01,690
‫A ta klasa ma całkiem sporo funkcji, z których możemy skorzystać podczas przechowywania przedmiotów na tacy.

97
00:07:01,720 --> 00:07:08,710
‫Teraz przejdę do samego dołu i pokażę tę funkcję o nazwie Num Short cztery liczby

98
00:07:08,830 --> 00:07:12,310
‫i mówi Zwraca liczbę elementów w tablicy.

99
00:07:12,310 --> 00:07:19,690
‫Możemy więc użyć tej funkcji, aby uzyskać liczbę elementów w naszej tablicy, gdy mamy już wszystkie wieże na

100
00:07:19,690 --> 00:07:20,380
‫świecie.

101
00:07:20,380 --> 00:07:26,080
‫Więc jeśli nazwiemy liczbę Wieży, możemy użyć jej jako wartości zwracanej przez naszą funkcję.

102
00:07:26,080 --> 00:07:31,930
‫Jak widzieliśmy, ustawiliśmy naszą wartość zwracaną dla tej funkcji, którą nazywamy get target tower count jako

103
00:07:31,930 --> 00:07:35,980
‫n 32, możemy zwrócić liczbę elementów w tablicy naszej wieży.

104
00:07:35,980 --> 00:07:41,230
‫Chciałbym więc rzucić wyzwanie zaimplementowaniu tej funkcji pobierania docelowej liczby wież.

105
00:07:41,230 --> 00:07:44,710
‫Więc utwórz lokalną tablicę t aktora typu A.

106
00:07:44,710 --> 00:07:47,110
‫Możesz nazwać to wieżami lub jak chcesz.

107
00:07:47,110 --> 00:07:52,930
‫Teraz użyj swojej gry, zagraj w funkcję statyki, zdobądź wszystkich aktorów klasy i upewnij się, że podajesz

108
00:07:52,930 --> 00:07:54,220
‫prawidłowe parametry wejściowe.

109
00:07:54,220 --> 00:08:00,310
‫Teraz, po wywołaniu tej funkcji, twoja tacka będzie zawierać wskaźniki do wszystkich wież w

110
00:08:00,310 --> 00:08:06,850
‫naszym świecie, więc możesz po prostu zwrócić liczbę wież za pomocą funkcji num, która należy do

111
00:08:06,850 --> 00:08:07,930
‫klasy tacy.

112
00:08:07,930 --> 00:08:10,660
‫Więc śmiało, zatrzymaj wideo i zaimplementuj.

113
00:08:10,660 --> 00:08:12,640
‫Uzyskaj teraz liczbę wież docelowych.

114
00:08:15,670 --> 00:08:16,000
‫Dobra.

115
00:08:16,000 --> 00:08:17,980
‫Więc tutaj jest docelowa liczba wież.

116
00:08:18,010 --> 00:08:24,250
‫Teraz pierwszą rzeczą, którą zamierzam zrobić, jest utworzenie lokalnej tablicy t określającej wskaźnik aktora jako typ

117
00:08:24,250 --> 00:08:26,590
‫elementu, który ta tablica powinna przechowywać.

118
00:08:26,590 --> 00:08:31,720
‫I zamierzam nazwać te wieże, teraz muszę nazwać was statystykami rozgrywki, więc muszę się upewnić, że

119
00:08:31,720 --> 00:08:33,100
‫ten nagłówek jest uwzględniony.

120
00:08:33,130 --> 00:08:38,830
‫Teraz widzę, że tak jest, ponieważ używamy go w niektórych innych naszych funkcjach, ale dobrze jest to

121
00:08:38,830 --> 00:08:39,340
‫sprawdzić.

122
00:08:39,370 --> 00:08:47,380
‫Następnie mogę wykorzystać statystyki rozgrywki i zadzwonić do wszystkich aktorów z klasą.

123
00:08:47,410 --> 00:08:54,130
‫Teraz pierwsze dane wejściowe to obiekt kontekstu świata, który zamierzam przekazać w tym, a następnie

124
00:08:54,130 --> 00:08:55,990
‫podklasa reprezentująca klasę aktora.

125
00:08:55,990 --> 00:09:03,430
‫Wspomniałem, że możemy użyć statycznej klasy tower, która zwróci klasę U reprezentującą klasę

126
00:09:03,430 --> 00:09:04,270
‫tower.

127
00:09:04,300 --> 00:09:09,190
‫Teraz znowu, dobrym pomysłem jest upewnienie się, że uwzględniamy wieże, którymi jesteśmy.

128
00:09:09,220 --> 00:09:14,740
‫Teraz trzecim i ostatnim parametrem będzie taca i możemy przejść przez wieże.

129
00:09:14,740 --> 00:09:21,340
‫Więc kiedy ta funkcja zostanie wywołana, wieże będą teraz zawierać wskaźniki do wszystkich wież na

130
00:09:21,340 --> 00:09:21,880
‫świecie.

131
00:09:21,880 --> 00:09:28,000
‫W rzeczywistości, gdyby istniały jakieś obiekty klasy, która wywodzi się z wież, również je otrzymalibyśmy.

132
00:09:28,000 --> 00:09:33,780
‫Ponieważ mamy tablicę towers, możemy po prostu zwrócić liczbę elementów w tej tablicy.

133
00:09:33,790 --> 00:09:40,660
‫Więc użyję instrukcji return i użyję towers dot num, a teraz mamy docelową liczbę wież.

134
00:09:40,660 --> 00:09:41,740
‫Więc to jest świetne.

135
00:09:41,740 --> 00:09:48,220
‫Możemy to wykorzystać do zainicjowania naszej liczby wież, które nazwaliśmy wieżami docelowymi i możemy to zrobić, gdy

136
00:09:48,220 --> 00:09:49,090
‫zaczynamy grę.

137
00:09:49,090 --> 00:09:51,780
‫Więc zamierzam to tutaj umieścić i zająć się rozpoczęciem gry.

138
00:09:51,790 --> 00:09:54,400
‫Właściwie chciałbym, żeby to była pierwsza rzecz, którą zrobimy.

139
00:09:54,400 --> 00:10:02,530
‫Więc zamierzam wziąć docelowe wieże i ustawić je na równą wartości zwracanej z uzyskania docelowej liczby wież.

140
00:10:02,560 --> 00:10:07,240
‫Teraz docelowe wieże powinny być inicjowane do liczby wież w naszym świecie.

141
00:10:07,240 --> 00:10:13,120
‫To świetnie, ale musimy aktualizować ten licznik za każdym razem, gdy umiera wieża, co oznacza,

142
00:10:13,120 --> 00:10:16,000
‫że musimy przejść do funkcji śmierci aktora.

143
00:10:16,000 --> 00:10:22,660
‫I tutaj, jeśli rzuciliśmy martwego aktora na zniszczoną wieżę, to po tym, jak zajmiemy

144
00:10:22,660 --> 00:10:30,430
‫się zniszczeniem, powinniśmy zaktualizować naszą zmienną docelowej wieży, aby móc powiedzieć docelowe wieże i użyć operatora dekrementacji.

145
00:10:30,430 --> 00:10:35,560
‫Możemy użyć operatora dekrementacji post lub operatora sytuacji.

146
00:10:35,560 --> 00:10:41,800
‫Obie te czynności będą skutkowały tym samym działaniem, które polega na zabraniu docelowych wież i odjęciu od nich jednej.

147
00:10:41,800 --> 00:10:48,220
‫Teraz, gdy tylko odejmiemy jeden od docelowych wież, teraz musimy sprawdzić, czy docelowe wieże

148
00:10:48,220 --> 00:10:49,660
‫osiągnęły zero.

149
00:10:49,660 --> 00:10:55,150
‫Więc zamierzam umieścić tutaj, jeśli sprawdź, czy wieże Target osiągnęły zero.

150
00:10:55,780 --> 00:11:02,380
‫Teraz, jak tylko to się stanie, wiemy, że gra powinna się skończyć, więc możemy

151
00:11:02,710 --> 00:11:10,660
‫wywołać przejście funkcji game over w prawdziwej grze 4b1, ponieważ zniszczyliśmy wszystkie wieże i możemy uznać to za wygraną.

152
00:11:10,660 --> 00:11:13,180
‫Teraz przejdźmy dalej i skompilujmy nasz kod.

153
00:11:13,180 --> 00:11:18,670
‫Teraz, z powrotem w edytorze, chciałbym zrobić, zanim zakończymy ten film, przejść do planu trybu

154
00:11:18,670 --> 00:11:19,420
‫gry.

155
00:11:19,420 --> 00:11:21,040
‫Oto melodia dźwiękowa.

156
00:11:21,040 --> 00:11:24,400
‫Dzięki trybowi gry i mamy tę grę startową.

157
00:11:24,400 --> 00:11:29,650
‫Tworzymy widżet rozpoczęcia gry, dodając go do widoku, abyśmy mogli zobaczyć

158
00:11:29,650 --> 00:11:31,780
‫licznik czasu rozpoczęcia gry.

159
00:11:31,780 --> 00:11:39,190
‫Wiemy więc, że nazywa się start game, ale musimy również zaimplementować naszą grę z możliwością wdrożenia

160
00:11:39,190 --> 00:11:39,820
‫planu.

161
00:11:39,820 --> 00:11:47,260
‫Więc kliknę prawym przyciskiem myszy i wpiszę game over i oto nasze wydarzenie, game over i sprawdź to.

162
00:11:47,290 --> 00:11:50,860
‫Zauważ, że mamy tę jedną grę i jest to wartość logiczna.

163
00:11:50,860 --> 00:11:57,220
‫Więc kiedy wywołujemy tę funkcję z C++, przekazujemy wartość logiczną dla B jednej gry.

164
00:11:57,220 --> 00:12:04,270
‫Węzeł zdarzenia planu usuwa małą literę B i umieszcza spację między jedynką a grą jako coś w rodzaju uprzejmości

165
00:12:04,270 --> 00:12:05,440
‫dla nas.

166
00:12:05,440 --> 00:12:10,150
‫Teraz stworzymy kilka widżetów, abyśmy mogli zobaczyć, kiedy wygraliśmy lub przegraliśmy grę, ale zrobimy

167
00:12:10,150 --> 00:12:11,650
‫to w przyszłym filmie.

168
00:12:11,650 --> 00:12:17,770
‫Na razie chcę tylko potwierdzić, że jest to wywoływane i wywoływane poprawnie, więc mogę to zrobić z

169
00:12:17,770 --> 00:12:22,180
‫węzłem wydruku i możemy wydrukować wartość na podstawie tej wartości logicznej.

170
00:12:22,180 --> 00:12:29,080
‫Jeśli kliknę i przeciągnę tę wartość logiczną bezpośrednio do wejścia w łańcuchu, zobaczymy, że istnieje konwersja wartości logicznej

171
00:12:29,080 --> 00:12:30,280
‫na łańcuch.

172
00:12:30,280 --> 00:12:37,420
‫Jest to kolejny wygodny węzeł konwersji, który przekonwertuje dla nas wartość logiczną na łańcuch, a jego

173
00:12:37,420 --> 00:12:43,690
‫funkcjonalność polega na konwersji na słowo prawda lub fałsz na podstawie wartości logicznej wartości

174
00:12:43,690 --> 00:12:44,350
‫logicznej.

175
00:12:44,710 --> 00:12:46,120
‫Dlaczego więc tego nie przetestujemy?

176
00:12:46,120 --> 00:12:48,040
‫Mam zamiar skompilować i uruchomić odtwarzanie.

177
00:12:49,400 --> 00:12:52,570
‫W porządku, teraz jestem gotów spróbować wygrać mecz.

178
00:12:52,580 --> 00:12:55,340
‫Mam nadzieję, że nie przegram, zanim to zrobię.

179
00:12:55,430 --> 00:13:01,430
‫Przegrałem grę i możesz zobaczyć fałszywe wydrukowane w lewym górnym rogu ekranu.

180
00:13:01,430 --> 00:13:08,570
‫Więc teraz wiemy, że przegrana w grze powoduje, że w przypadku zdarzenia zostanie odwołany, a fałsz zostanie przekazany, musimy

181
00:13:08,570 --> 00:13:12,050
‫upewnić się, że prawda jest przekazywana, gdy wygrywamy grę.

182
00:13:12,050 --> 00:13:14,900
‫Spróbujmy więc zabić wszystkie wieżyczki.

183
00:13:15,380 --> 00:13:18,020
‫Więc muszę naprawdę postarać się nie oberwać.

184
00:13:18,020 --> 00:13:19,250
‫Och, już dostałem.

185
00:13:19,910 --> 00:13:21,560
‫To jest dość trudne.

186
00:13:22,840 --> 00:13:24,820
‫I tam idziemy.

187
00:13:24,820 --> 00:13:28,720
‫Prawda jest wydrukowana w lewym górnym rogu ekranu.

188
00:13:28,750 --> 00:13:31,600
‫Pojawia się tylko na kilka sekund, więc mogłeś to przegapić.

189
00:13:31,630 --> 00:13:32,350
‫Okej świetnie.

190
00:13:32,350 --> 00:13:35,050
‫Więc teraz mamy warunki wygranej i przegranej.

191
00:13:35,080 --> 00:13:41,380
‫Następnym krokiem jest pokazanie tego w formie widżetu na ekranie, abyśmy nie polegali na

192
00:13:41,380 --> 00:13:42,850
‫węźle łańcucha drukowania.

193
00:13:42,880 --> 00:13:48,010
‫Podsumowując, mamy teraz warunki wygranej i przegranej i jest tylko kilka rzeczy, które

194
00:13:48,010 --> 00:13:53,890
‫musimy zrobić, aby to dopracować, na przykład stworzyć widżety, które informują gracza, że wygrał lub przegrał grę.

195
00:13:53,890 --> 00:13:58,900
‫Policzyliśmy również liczbę wież za pomocą tacy i funkcji statystyk rozgrywki.

196
00:13:58,930 --> 00:14:00,600
‫Zdobądź wszystkich aktorów z klasy.

197
00:14:00,610 --> 00:14:01,270
‫Dobra robota.

198
00:14:01,270 --> 00:14:03,370
‫Ta gra naprawdę nadchodzi.

199
00:14:03,370 --> 00:14:09,220
‫W następnym filmie utworzymy te widżety, a następnie będziemy mogli zacząć dodawać efekty specjalne i

200
00:14:09,220 --> 00:14:10,840
‫dopracowywać naszą grę.

201
00:14:10,870 --> 00:14:12,520
‫Do zobaczenia w następnym filmie.