1
00:00:04,120 --> 00:00:04,630
‫好吧, 我会的

2
00:00:04,630 --> 00:00:08,980
‫所以我们这个视频的目标是实现我们的脑桥死亡｡

3
00:00:08,980 --> 00:00:17,770
‫所以如果我被我们的塔击中几次, 你会看到我消失了, 因为我的坦克死了｡

4
00:00:17,770 --> 00:00:24,220
‫如果我有足够的技巧, 如果我能摧毁其中一个, 你会看到它也消失了｡

5
00:00:24,220 --> 00:00:29,200
‫所以我们要在这段视频中为这些卒实现死亡｡

6
00:00:29,290 --> 00:00:31,240
‫你好, 欢迎回来｡

7
00:00:31,270 --> 00:00:36,790
‫现在, 我们已经应用伤害的兵时, 他们被击中的弹丸｡

8
00:00:36,790 --> 00:00:40,600
‫我们现在需要弄清楚我们如何处理死后的事情｡

9
00:00:40,600 --> 00:00:45,910
‫这意味着我们需要某种函数来处理特定参与者的销毁｡

10
00:00:45,910 --> 00:00:49,030
‫所以我们要创建一个句柄销毁函数｡

11
00:00:49,030 --> 00:00:55,510
‫我们还需要一个演员死亡函数,

12
00:00:55,510 --> 00:01:03,340
‫它可以让游戏模式处理当我们的世界中的演员死亡时会发生什么, 当一个特定的棋子的健康值达到零时, 我们将调用这个演员死亡函数｡

13
00:01:03,340 --> 00:01:07,630
‫让我们来谈谈如何实施该系统的路线图｡

14
00:01:07,630 --> 00:01:14,080
‫我们知道我们有一个投射物, 它调用了应用损害, 这导致了损害接受函数,

15
00:01:14,080 --> 00:01:18,610
‫对健康组件中的委托广播做出响应｡

16
00:01:18,610 --> 00:01:21,100
‫所以我们得想想接下来该怎么做｡

17
00:01:21,100 --> 00:01:26,230
‫好吧, 我们的游戏模式可以有一个功能来处理当一个演员死亡｡

18
00:01:26,230 --> 00:01:30,370
‫所以在受到的伤害中, 我们可以检查生命值是否为零｡

19
00:01:30,370 --> 00:01:38,440
‫在这一点上, 我们可以调用游戏模式中的演员死亡函数, 从那里我们的兵可以处理它的破坏｡

20
00:01:38,440 --> 00:01:45,010
‫所以最终将由游戏模式来调用死亡演员的句柄销毁函数｡

21
00:01:45,010 --> 00:01:49,660
‫我们已经有了一个游戏计划, 现在让我们概述一下实施该计划的步骤｡

22
00:01:49,660 --> 00:01:58,900
‫首先, 我们要创建一个句柄销毁函数我们要把它放在基本的兵类中来处理当我们的兵死亡时应该发生的功能.

23
00:01:58,900 --> 00:02:04,090
‫我们也会在坦克和塔类中实现这个, 因为它们在死亡时都有自己独特的功能, 然后我们会创建一个actor

24
00:02:04,090 --> 00:02:09,520
‫died函数, 并将其放在游戏模式类中, 这样我们就可以从那里调用handle

25
00:02:09,520 --> 00:02:13,090
‫destruction了.

26
00:02:13,090 --> 00:02:18,730
‫之后我们将在游戏模式下的actor dead函数中调用handle destruction, 然后当健康值为零时,

27
00:02:18,730 --> 00:02:23,320
‫我们可以从健康值组件中调用actor dead｡

28
00:02:23,320 --> 00:02:27,640
‫因此, 让我们从创建句柄销毁函数的第一步开始｡

29
00:02:27,640 --> 00:02:33,430
‫现在我在Base Pond H中, 我想添加这个句柄销毁函数｡

30
00:02:33,430 --> 00:02:38,740
‫现在我打算在游戏模式下调用它, 这意味着它需要是一个公共函数,

31
00:02:38,740 --> 00:02:42,850
‫这样我就可以把这个函数放在这里的public部分.

32
00:02:42,940 --> 00:02:46,840
‫它是空的, 我称之为手柄破坏｡

33
00:02:47,890 --> 00:02:50,710
‫现在, 它不需要接受任何输入参数｡

34
00:02:50,860 --> 00:02:55,360
‫它只负责销毁这枚棋子.

35
00:02:55,360 --> 00:03:02,770
‫让我们在基本兵CP文件中实现这个函数, 我将把它放在构造函数下面.

36
00:03:02,770 --> 00:03:10,180
‫我有一个销毁句柄, 我会把一个基本的兵类名放在函数名之前.

37
00:03:10,180 --> 00:03:15,640
‫这就是当任何一个基于基本卒的卒死亡时会发生的事情.

38
00:03:15,640 --> 00:03:21,040
‫所以我会在这里放置一个to do, 表示我们在句柄销毁函数中要做的事情｡

39
00:03:21,040 --> 00:03:26,800
‫我想在这里处理所有的视觉和声音效果, 这些效果都与卒的死亡有关｡

40
00:03:26,800 --> 00:03:32,860
‫所以我只讲视觉和声音效果, 我们就讲到这里,

41
00:03:32,860 --> 00:03:38,920
‫当我们讲到这节课的特效和声音部分时, 一定要记住要实现这个｡

42
00:03:38,920 --> 00:03:50,050
‫现在我们有了句柄销毁, 但我想在坦克和塔类中也放一个句柄销毁函数来处理当这些兵死亡时会发生什么｡

43
00:03:50,050 --> 00:03:54,670
‫而最简单的破坏方式也许是对我们的塔｡

44
00:03:54,670 --> 00:04:00,760
‫现在让我们进入H塔, 我们将在这里添加一个公共函数, 称为句柄销毁｡

45
00:04:00,760 --> 00:04:10,060
‫我将使用void句柄destruction来实现它, 并在tick函数下构建CP.

46
00:04:10,060 --> 00:04:18,130
‫这里是tick, 这里是handle destruction, 我将在函数名前加上一个塔, 就像这样｡

47
00:04:18,130 --> 00:04:24,280
‫现在在塔的句柄销毁函数中, 我想调用超级版本, 这样就可以调用基础兵的句柄销毁函数,

48
00:04:24,280 --> 00:04:29,800
‫当塔死亡时, 我们就可以得到那些视觉和声音效果｡

49
00:04:29,800 --> 00:04:35,650
‫所以我会说超级句柄销毁, 以确保它被调用｡

50
00:04:35,650 --> 00:04:39,040
‫在那之后, 我会摧毁这座塔｡

51
00:04:39,040 --> 00:04:40,390
‫现在我们已经看到了它是如何工作的｡

52
00:04:40,390 --> 00:04:45,820
‫我们只调用destroy函数, 它将处理塔的销毁｡

53
00:04:45,820 --> 00:04:54,910
‫所以我可以保存这个并关闭塔和CP文件, 现在我可以在坦克类中放置一个句柄销毁函数｡

54
00:04:54,910 --> 00:05:02,620
‫我将进入tank并在tick函数下声明一个公共函数, 名为handle destruction.

55
00:05:03,640 --> 00:05:10,870
‫我将在Tank CP中, 在tic下面实现这个函数,

56
00:05:10,870 --> 00:05:13,360
‫别忘了在函数名前加上tank.

57
00:05:13,510 --> 00:05:17,950
‫现在, 就像在塔类中一样, 我们想把毁灭称为超级处理｡

58
00:05:19,300 --> 00:05:22,120
‫这样我们就能获得视觉和声音效果｡

59
00:05:22,150 --> 00:05:24,910
‫对于坦克, 我们要做一些不同的事情｡

60
00:05:24,940 --> 00:05:27,700
‫我想把坦克藏起来而不是毁掉它｡

61
00:05:27,700 --> 00:05:33,730
‫然后我们可以禁用它的TIC功能, 这样它就仍然存在于世界上, 我们仍然拥有它｡

62
00:05:33,730 --> 00:05:35,740
‫所以我们仍然可以从摄像机上看到那个画面｡

63
00:05:35,770 --> 00:05:38,610
‫只不过我们无法看到它或移动它｡

64
00:05:38,620 --> 00:05:47,710
‫所以要隐藏坦克我们可以调用一个函数set actor hidden in game, 这将取一个布尔值｡

65
00:05:47,710 --> 00:05:51,400
‫如果我们传递true, 那么我们将有效地隐藏坦克｡

66
00:05:51,430 --> 00:05:55,420
‫现在我还想禁用滴答声, 这也有一个功能｡

67
00:05:55,420 --> 00:05:58,810
‫这叫做设置演员控制点使能｡

68
00:05:59,770 --> 00:06:05,260
‫为此我将传入false, 这将禁用tank的ticking｡

69
00:06:05,260 --> 00:06:08,800
‫这就完成了句柄销毁函数｡

70
00:06:08,800 --> 00:06:11,590
‫所以我们有了句柄销毁函数｡

71
00:06:11,620 --> 00:06:16,020
‫我们的下一步是在游戏模式中创建一个演员死亡函数｡

72
00:06:16,030 --> 00:06:17,440
‫让我们来实现它｡

73
00:06:17,440 --> 00:06:25,870
‫我现在在tune tank游戏模式下, 我可以创建actor died函数,

74
00:06:25,870 --> 00:06:32,200
‫现在我打算从health组件类调用actor died, 这意味着它也需要是一个公共函数.

75
00:06:32,440 --> 00:06:37,590
‫因此, 我将添加一个public部分, 并创建actor died函数｡

76
00:06:37,600 --> 00:06:40,930
‫现在这个是无效的, 我称之为演员死亡｡

77
00:06:41,170 --> 00:06:49,740
‫这可以简单地采取一个演员指针称为死演员, 现在我们可以实现演员死在调坦克游戏模式.

78
00:06:50,110 --> 00:07:00,220
‫所以我把它放在这里, 在名字前面加上一个tune tank游戏模式, 现在我们有了一个演员死亡函数｡

79
00:07:00,220 --> 00:07:07,030
‫现在我想检查一下死去的演员是不是坦克, 也就是说我需要一个变量来代表坦克.

80
00:07:07,030 --> 00:07:09,460
‫所以回到调坦克游戏模式｡

81
00:07:09,460 --> 00:07:17,290
‫我将创建一个私有区域, 并添加一个tank变量, 然后对其进行正向声明.

82
00:07:17,290 --> 00:07:23,290
‫这是一个A类型的tank指针, 我只需要调用这个tank, 我需要用tank的地址初始化它,

83
00:07:23,290 --> 00:07:27,760
‫然后我就可以开始玩了.

84
00:07:27,760 --> 00:07:33,640
‫现在我们已经看到开始play是一个受保护的函数, 我们将在游戏模式中保护它, 这样我们就可以覆盖, begin,

85
00:07:33,640 --> 00:07:36,400
‫play.

86
00:07:36,400 --> 00:07:44,580
‫我会说virtual void, 开始, play, override, 我可以在tune tank, 游戏模式下实现它｡

87
00:07:44,860 --> 00:07:45,610
‫是的｡

88
00:07:45,640 --> 00:07:52,840
‫所以这将是无效的开始播放, 我将使用调坦克, 游戏模式类名｡

89
00:07:52,990 --> 00:07:56,110
‫我要做的第一件事就是调用super开始play｡

90
00:07:57,550 --> 00:08:03,040
‫这样我们就可以得到父功能, 我可以得到玩家典当使用游戏静态｡

91
00:08:03,040 --> 00:08:11,680
‫所以我首先要把游戏性统计学包括进来, 这是我们已经看到的kismet和游戏性统计学｡

92
00:08:11,800 --> 00:08:17,290
‫在这里, 我可以把坦克和分配它的价值, 青年游戏静态｡

93
00:08:18,230 --> 00:08:19,550
‫吉他手手掌｡

94
00:08:20,360 --> 00:08:26,390
‫这需要一个世界上下文对象, 我们可以用它来表示,

95
00:08:26,390 --> 00:08:30,200
‫我用零作为玩家索引因为坦克永远都是零.

96
00:08:30,200 --> 00:08:37,430
‫现在我们知道了jet player-—返回一个A-—指针, tank是type A tank, 一个子类｡

97
00:08:37,430 --> 00:08:44,510
‫我们已经看到了如果我们想把结果存储在一个tank指针中, 我们需要把它转换成一个tank类｡

98
00:08:44,510 --> 00:08:47,450
‫首先, 我将包括水箱顶盖｡

99
00:08:47,450 --> 00:08:53,330
‫所以我会把坦克H也包括进去然后我会把它投射到坦克上.

100
00:08:53,390 --> 00:09:00,440
‫所以我会说cast to a tank我会把get player返回的值转换成.

101
00:09:00,440 --> 00:09:02,900
‫所以我把它放在括号里｡

102
00:09:03,260 --> 00:09:08,720
‫现在我们有一个指向玩家的指针——以A坦克指针的形式｡

103
00:09:08,720 --> 00:09:14,090
‫现在我们有了坦克, 我们可以检查一下我们死去的演员是不是坦克｡

104
00:09:14,090 --> 00:09:21,800
‫所以我们可以说, 如果死演员加倍等于坦克, 现在坦克可能是空的｡

105
00:09:21,800 --> 00:09:28,940
‫这没关系, 因为如果Tank是null, dead actor指向tank本身,

106
00:09:28,940 --> 00:09:35,060
‫那么if检查就会失败, 我们不会去访问一个null指针, 因为我们不会进入它的内部.

107
00:09:35,060 --> 00:09:41,900
‫现在, 如果死去的演员实际上是坦克, 那么我想调用坦克句柄销毁函数｡

108
00:09:41,900 --> 00:09:44,870
‫所以我们要叫坦克把手销毁｡

109
00:09:45,680 --> 00:09:52,100
‫现在, 在调用句柄销毁函数之后,

110
00:09:52,100 --> 00:09:58,550
‫我还想禁用坦克pod的输入, 这样我就可以得到坦克并调用坦克继承的内置函数, 称为禁用输入｡

111
00:09:59,540 --> 00:10:03,200
‫现在禁用输入需要一个A播放器控制器｡

112
00:10:03,200 --> 00:10:10,430
‫现在我们知道坦克类, 如果我们来到坦克H,

113
00:10:10,430 --> 00:10:19,160
‫有一个玩家控制器ref变量, 它是一个指向玩家控制器的指针, 这就是为什么我开始认为ref这个变量的名字很糟糕.

114
00:10:19,160 --> 00:10:21,320
‫因为它不是指涉, 所以是指标｡

115
00:10:21,320 --> 00:10:24,260
‫我更愿意称它为坦克玩家控制器｡

116
00:10:24,350 --> 00:10:27,200
‫所以, 我们为什么不把它重新命名呢？

117
00:10:27,200 --> 00:10:33,530
‫这是开发人员经常做的事情, 当他们意识到他们给了一个变量, 一个坏名字｡

118
00:10:33,530 --> 00:10:36,290
‫所以这段代码有一种方法可以很容易地做到这一点｡

119
00:10:36,290 --> 00:10:42,350
‫我可以突出显示这个变量, 然后按F2键, 它会要求我重命名它｡

120
00:10:42,590 --> 00:10:45,710
‫我把这个叫做坦克玩家控制器｡

121
00:10:46,100 --> 00:10:47,480
‫现在看看这个

122
00:10:47,480 --> 00:10:49,790
‫这里叫做坦克玩家控制器｡

123
00:10:49,790 --> 00:10:54,350
‫如果我去坦克CP, 我会看到它在这里重命名｡

124
00:10:54,350 --> 00:11:00,530
‫所以我不需要进去找它, 找到每个球员, 控制器, 裁判的实例｡

125
00:11:00,530 --> 00:11:06,050
‫我可以搜索坦克玩家控制器, 看到它的变化无处不在, 它在这里使用｡

126
00:11:06,050 --> 00:11:08,960
‫所以这是一个很好的重构技巧｡

127
00:11:08,960 --> 00:11:17,180
‫所以无论如何, 回到这里在调坦克游戏模式, 我需要禁用输入的坦克, 这需要一个球员控制器｡

128
00:11:17,360 --> 00:11:25,550
‫所以我首先要检查, 以确保坦克球员控制器是有效的, 如果坦克和我需要访问该球员控制器｡

129
00:11:25,550 --> 00:11:30,440
‫但回想一下, 在tank中, 我们的玩家控制器变量是私有的｡

130
00:11:30,440 --> 00:11:36,860
‫现在我们可以公开这个变量并将其公开, 或者我们可以为这个变量创建一个公共getter函数｡

131
00:11:36,860 --> 00:11:40,340
‫我宁愿创建一个公共getter, 因为这是更好的编程实践｡

132
00:11:40,340 --> 00:11:46,610
‫在公共部分, 我将为坦克玩家控制器创建一个公共getter.

133
00:11:46,610 --> 00:11:55,340
‫现在它会返回一个A玩家控制器指针这个函数叫做get tank player.

134
00:11:55,340 --> 00:12:02,900
‫控制器getter通常是变量的名字, get在前面,

135
00:12:02,900 --> 00:12:10,970
‫它们通常也是cost函数, 因为这个函数不是用来改变这个类的任何东西的, 它只返回播放器控制器.

136
00:12:10,970 --> 00:12:16,760
‫所以我们要返回坦克玩家控制器, 这就是它要做的｡

137
00:12:16,760 --> 00:12:25,640
‫现在我们有了一个坦克玩家控制器的公共getter函数, 我们可以在游戏模式中访问玩家控制器｡

138
00:12:25,880 --> 00:12:33,080
‫所以我们要说如果坦克有一个坦克玩家控制器, 并在这里进行函数调用｡

139
00:12:33,080 --> 00:12:38,450
‫如果我们到达if语句的内部,

140
00:12:38,450 --> 00:12:46,400
‫那么玩家控制器是有效的, 所以我们可以把这个调用移到这里的tank禁用输入, 我们将把tank玩家控制器传递到禁用输入｡

141
00:12:48,400 --> 00:12:51,950
‫所以我们在这里也调用tank get player controller｡

142
00:12:51,970 --> 00:12:57,910
‫现在, 当我们访问播放器控制器时, 我还想将播放器控制器设为show mouse

143
00:12:57,910 --> 00:13:03,640
‫cursor布尔成员变量, 并将其设置为false｡

144
00:13:03,640 --> 00:13:08,830
‫因此, 我们禁用输入, 同时确保不显示鼠标光标｡

145
00:13:08,830 --> 00:13:13,400
‫这样就可以处理坦克死亡时的功能｡

146
00:13:13,420 --> 00:13:21,010
‫现在, 如果死去的演员不是坦克, 我会检查它是否是塔类的一个实例｡

147
00:13:21,010 --> 00:13:23,200
‫所以我要在这里添加一个else if｡

148
00:13:23,320 --> 00:13:26,410
‫那么这个elseif的条件是什么呢？

149
00:13:26,440 --> 00:13:35,800
‫我想看看死了的演员能不能被选到A塔, 也就是说我需要把塔类也包括进去.

150
00:13:35,890 --> 00:13:37,300
‫所以包括塔｡

151
00:13:38,170 --> 00:13:40,270
‫然后我将尝试投出｡

152
00:13:40,270 --> 00:13:44,770
‫所以我会说cast, 它使用尖括号和圆括号｡

153
00:13:44,770 --> 00:13:50,410
‫我们铸造的也是一座塔, 我们铸造的是死的｡

154
00:13:50,410 --> 00:13:53,410
‫演员将尝试扮演死去的演员｡

155
00:13:53,410 --> 00:13:59,410
‫现在我们实际上可以取这个类型转换的结果并赋值给它, 然后创建一个局部变量｡

156
00:13:59,410 --> 00:14:11,470
‫在条件式中我们可以说一个塔指针我们可以调用这个被摧毁的塔并给它赋值从这个强制转换返回的值.

157
00:14:11,470 --> 00:14:18,660
‫如果我们这么做了, 我们就能接触到这个被摧毁的演员, 也就是我们被扔到塔上的死去的演员｡

158
00:14:18,670 --> 00:14:22,630
‫现在, 如果成功了, 我们就能进入到其他空间里｡

159
00:14:22,630 --> 00:14:24,670
‫然后我们就可以把我们消灭了｡

160
00:14:25,490 --> 00:14:31,430
‫塔和我们可以简单地称之为毁灭柄｡

161
00:14:32,870 --> 00:14:39,800
‫所以现在我们在游戏模式中有一个演员死亡函数, 它调用了处理破坏,

162
00:14:39,800 --> 00:14:43,910
‫也处理了一些坦克的死亡相关功能｡

163
00:14:44,180 --> 00:14:45,980
‫这就是第二步｡

164
00:14:45,980 --> 00:14:53,540
‫创建一个actor ded函数, 在创建的时候我们还调用了actor ded函数中的句柄销毁｡

165
00:14:53,540 --> 00:14:58,150
‫所以我们的最后一步是在健康值为零时调用演员死亡｡

166
00:14:58,160 --> 00:15:07,250
‫为了调用这个存在于游戏模式中的函数, 我们的健康组件需要一个变量来存储游戏模式的地址｡

167
00:15:07,250 --> 00:15:10,340
‫让我们进入健康组件类｡

168
00:15:10,340 --> 00:15:16,100
‫这是健康组件, 我将在底部添加一个私有变量｡

169
00:15:16,100 --> 00:15:25,730
‫这将是A型调坦克游戏模式指针, 我们将称之为调坦克游戏模式.

170
00:15:25,730 --> 00:15:32,480
‫现在我将向前声明它, 这样就不必在这里包含它的头文件, 然后我们需要访问游戏模式｡

171
00:15:32,480 --> 00:15:38,990
‫现在我们转到健康组件CP, 如果我向上滚动, 我会在这里看到开始播放功能,

172
00:15:38,990 --> 00:15:41,690
‫这是了解游戏模式的最佳位置｡

173
00:15:41,690 --> 00:15:44,840
‫同样, 将它放在构造函数中也太早了｡

174
00:15:44,840 --> 00:15:50,530
‫我们需要确保在尝试访问游戏模式之前, 该模式已经构建并存在｡

175
00:15:50,540 --> 00:15:57,200
‫现在这里有一个关于游戏静态的函数, 叫做Get Game Mode, 它返回当前的游戏模式,

176
00:15:57,200 --> 00:16:01,610
‫如果不能在客户端上检索到它, 它会返回null｡

177
00:16:01,850 --> 00:16:07,730
‫现在在客户端与多人游戏编程, 我们不必担心｡

178
00:16:07,730 --> 00:16:18,230
‫我们在唯一的一台机器上运行游戏, 所以让我们向下滚动, 我们将看到一个游戏模式库接受一个世界上下文对象｡

179
00:16:18,230 --> 00:16:24,080
‫这只是世界中的一个对象, 我们已经看到了如何处理世界上下文对象｡

180
00:16:24,080 --> 00:16:29,030
‫所以这存在于游戏静态中, 让我们把它包括在内｡

181
00:16:29,030 --> 00:16:35,330
‫在健康组件中, CP将粘贴我们的包含游戏静态信息, 然后我们将在此处调用get game

182
00:16:35,330 --> 00:16:37,490
‫mode并开始游戏｡

183
00:16:37,790 --> 00:16:40,670
‫所以我们要说调整坦克, 游戏模式｡

184
00:16:42,030 --> 00:16:44,380
‫并将其设置为您的值｡

185
00:16:44,400 --> 00:16:50,940
‫游戏静态获取游戏模式和世界上下文对象｡

186
00:16:50,940 --> 00:16:54,750
‫我将把它传递进去, 现在我们进入了博弈模式.

187
00:16:54,750 --> 00:17:01,080
‫当然, 要得到游戏模式, 返回一个游戏模式基类, 我们试图把它保存在子类中,

188
00:17:01,080 --> 00:17:06,810
‫一个tune tank游戏模式, 这意味着我们需要投出.

189
00:17:06,810 --> 00:17:07,380
‫没错, 我是说...

190
00:17:07,380 --> 00:17:17,580
‫所以我们需要说cast to a tune tanks游戏模式, 我们从get游戏模式中铸造结果｡

191
00:17:17,580 --> 00:17:20,430
‫所以我把它放在括号里｡

192
00:17:20,430 --> 00:17:22,410
‫而且我们使用的是调音坦克游戏模式｡

193
00:17:22,410 --> 00:17:24,840
‫因此, 我将在顶部包含该头文件｡

194
00:17:24,840 --> 00:17:26,970
‫所以我要说包括｡

195
00:17:28,960 --> 00:17:32,120
‫调整坦克游戏模式｡

196
00:17:33,100 --> 00:17:36,960
‫所以我们在健康组件中有游戏模式｡

197
00:17:36,970 --> 00:17:44,080
‫我们已经准备好进入伤害状态, 看看我们的生命值是否为零｡

198
00:17:44,140 --> 00:17:52,060
‫在这种情况下, 我们可以使用tune tank游戏模式指针来调用函数actor died,

199
00:17:52,060 --> 00:17:59,740
‫传入死去的演员, 这将是你的挑战, 所以在health组件类中, 在damage

200
00:17:59,740 --> 00:18:06,910
‫taken中, 你将检查health的值是达到了零还是低于零｡

201
00:18:06,940 --> 00:18:11,260
‫如果真是那样的话, 那么就叫男主角使用游戏模式死掉吧｡

202
00:18:11,260 --> 00:18:17,800
‫因为我们有一个指向游戏模式的指针, 所以不要忘记先检查一下这个指针是否不为空｡

203
00:18:17,800 --> 00:18:21,940
‫一旦你叫演员死了, 你就需要换一个演员｡

204
00:18:21,940 --> 00:18:25,000
‫你要把死去的演员传过去｡

205
00:18:25,000 --> 00:18:30,370
‫因此, 暂停视频, 并在损坏功能中实现这一点｡

206
00:18:33,280 --> 00:18:33,670
‫好吧, 我会的

207
00:18:33,670 --> 00:18:36,720
‫所以我们已经从健康中减去了伤害｡

208
00:18:36,730 --> 00:18:41,220
‫现在我们准备检查健康值是否已达到零｡

209
00:18:41,230 --> 00:18:49,450
‫所以我会说如果健康指数小于或等于零, 如果是这样的话, 跟注是合适的.

210
00:18:49,480 --> 00:18:55,090
‫现在演员死了, 因为我们需要检查一下游戏模式是否有效｡

211
00:18:55,090 --> 00:19:02,170
‫我可以在这里放置一个广告, 如果检查和检查, 看看是否调整坦克游戏模式是有效的｡

212
00:19:02,170 --> 00:19:07,060
‫如果它是null, 那么它将返回false, 我们不会进入if语句的内部｡

213
00:19:07,540 --> 00:19:14,050
‫所以如果我们到达if语句里面, tune tank游戏模式是有效的并且健康值已经达到零｡

214
00:19:14,050 --> 00:19:16,780
‫所以我们可以说调坦克, 游戏模式｡

215
00:19:17,980 --> 00:19:19,900
‫而我们可以称之为男主角死了｡

216
00:19:20,830 --> 00:19:27,160
‫这需要一个演员, 我们知道死去的演员将是受损的演员｡

217
00:19:27,160 --> 00:19:29,950
‫所以我们要忽略受损演员｡

218
00:19:30,130 --> 00:19:33,640
‫现在我们可以编译这个并看看那个｡

219
00:19:33,640 --> 00:19:35,380
‫我们有一个成功的编译器｡

220
00:19:35,380 --> 00:19:37,180
‫让我们回到编辑器｡

221
00:19:37,180 --> 00:19:40,690
‫在编辑器里, 我们为什么不继续测试死亡呢？

222
00:19:40,690 --> 00:19:45,790
‫让我们看看我能不能在自己被摧毁之前摧毁一些坦克｡

223
00:19:45,790 --> 00:19:47,680
‫这将是一种挑战｡

224
00:19:47,710 --> 00:19:48,670
‫有一个｡

225
00:19:48,670 --> 00:19:52,030
‫我杀了一个, 我得到了第二个｡

226
00:19:52,030 --> 00:19:53,230
‫我死了｡

227
00:19:53,650 --> 00:20:01,840
‫所以你可以看到这个游戏是一个更有趣的现在我们已经添加了死亡和破坏我们的池塘｡

228
00:20:01,840 --> 00:20:03,550
‫所以这是伟大的｡

229
00:20:03,850 --> 00:20:11,050
‫好了, 我希望你们能给予自己一个大大的鼓励, 因为在这个视频中我们处理了死亡演员,

230
00:20:11,050 --> 00:20:18,010
‫这涉及到游戏中这些职业之间的大量互动｡

231
00:20:18,100 --> 00:20:24,940
‫现在死亡的实现方式是池塘简单地消失了, 这意味着我们还需要一些东西｡

232
00:20:25,030 --> 00:20:26,890
‫我们需要赢输的条件｡

233
00:20:26,890 --> 00:20:30,490
‫我们需要一种方法来告诉玩家他们是赢了还是输了｡

234
00:20:30,490 --> 00:20:33,220
‫而且我们还需要那些特效｡

235
00:20:33,340 --> 00:20:36,430
‫我们需要一些声音, 我们需要一些爆炸｡

236
00:20:36,430 --> 00:20:39,520
‫这些事情很快就会发生｡

237
00:20:39,520 --> 00:20:41,170
‫所以恭喜你

238
00:20:41,170 --> 00:20:46,570
‫你已经走了很长的路, 只剩下几步路要走｡

239
00:20:46,600 --> 00:20:48,310
‫下一个视频里见｡