1
00:00:07,980 --> 00:00:08,470
[Powered by Google Translate] ZAMYLA陈：好的。

2
00:00:08,470 --> 00:00:10,960
大家好，欢迎来到演练0。

3
00:00:10,960 --> 00:00:12,670
我的名字叫Zamyla，我会带领这些

4
00:00:12,670 --> 00:00:14,450
演练今年。

5
00:00:14,450 --> 00:00:17,650
CS50，是伴随着每一个问题集演练

6
00:00:17,650 --> 00:00:20,390
据此，我们将通过本周的习题集，谈

7
00:00:20,390 --> 00:00:22,760
通过谈如何开始，讨论不同

8
00:00:22,760 --> 00:00:26,120
技巧和提示，真正把问题设置成

9
00:00:26,120 --> 00:00:27,600
一些管理的叮咬。

10
00:00:27,600 --> 00:00:29,630
我也很乐意回答任何问题，

11
00:00:29,630 --> 00:00:31,440
有问题上。

12
00:00:31,440 --> 00:00:33,320
事不宜迟，我很高兴你在这里，无论你是

13
00:00:33,320 --> 00:00:35,590
这里的人，或在网上调整。

14
00:00:35,590 --> 00:00:36,840
让我们开始吧。

15
00:00:39,940 --> 00:00:42,420
>> 因此，设置在第一p-CS50  - 

16
00:00:42,420 --> 00:00:44,590
其实，我们不打算进入打字和机

17
00:00:44,590 --> 00:00:45,630
代码相当，但东西。

18
00:00:45,630 --> 00:00:47,360
实际上，我们将要使用划痕，这是一个

19
00:00:47,360 --> 00:00:49,860
程序，它允许我们做一些拖放

20
00:00:49,860 --> 00:00:50,780
编程。

21
00:00:50,780 --> 00:00:54,020
因此，即使我们不打字，它真的可以让我们

22
00:00:54,020 --> 00:00:55,870
探索的一些基本概念，

23
00:00:55,870 --> 00:00:58,710
我们将使用整个CS50。

24
00:00:58,710 --> 00:01:01,260
现在，一些这些概念

25
00:01:01,260 --> 00:01:02,860
在“工具箱”中列在这里。

26
00:01:02,860 --> 00:01:05,830
我想要做的每一个演练是为您介绍所有

27
00:01:05,830 --> 00:01:08,390
有一组工具，你可以使用的演练。

28
00:01:08,390 --> 00:01:09,140
所以，不用担心。

29
00:01:09,140 --> 00:01:11,710
我们将在所有这些条款，所有这些

30
00:01:11,710 --> 00:01:13,320
在本演练的理论。

31
00:01:13,320 --> 00:01:15,790
现在，你是否使用所有这些工具，或只是

32
00:01:15,790 --> 00:01:19,340
其中的一些，这是真的很好，知道你的装备

33
00:01:19,340 --> 00:01:21,225
与能够解决这个问题集。

34
00:01:25,650 --> 00:01:29,110
>> 因此，在从无到有，行话，你需要知道的是什么

35
00:01:29,110 --> 00:01:30,110
一个精灵。

36
00:01:30,110 --> 00:01:34,280
因此，每个对象或每一个字符，无论是猫狗

37
00:01:34,280 --> 00:01:36,450
或一球，被称为精灵。

38
00:01:36,450 --> 00:01:40,710
所以，如果我想的话，说，两只猫 - 不论他们是

39
00:01:40,710 --> 00:01:41,360
相同的 - 

40
00:01:41,360 --> 00:01:45,630
我需要两个独立的精灵在Scratch。

41
00:01:45,630 --> 00:01:49,250
因此，精灵与他们有关联的脚本。

42
00:01:49,250 --> 00:01:51,360
脚本实际上是什么，你要建设 - 

43
00:01:51,360 --> 00:01:53,290
拖放 - 与您的块。

44
00:01:53,290 --> 00:01:57,490
还等什么脚本是怎么样的判断和定义

45
00:01:57,490 --> 00:02:00,090
精灵的行为。

46
00:02:00,090 --> 00:02:03,130
实际上精灵不只是图像，因为我们有

47
00:02:03,130 --> 00:02:05,790
服饰也与小精灵种

48
00:02:05,790 --> 00:02:07,430
确定的精灵看起来像什么。

49
00:02:07,430 --> 00:02:11,000
对于一个给定的精灵，你可以有一个以上的服装。

50
00:02:11,000 --> 00:02:14,860
>> 因此，在一些点在临时程序，因为我们将展示

51
00:02:14,860 --> 00:02:17,150
今天晚些时候在演练中，你其实可以

52
00:02:17,150 --> 00:02:19,640
改变你的精灵的装束，使它看起来也

53
00:02:19,640 --> 00:02:22,490
略有不同或完全不同的。

54
00:02:22,490 --> 00:02:26,290
因此，有三种方法创建一个精灵在Scratch。

55
00:02:26,290 --> 00:02:28,970
一，你可以将自己的在Scratch

56
00:02:28,970 --> 00:02:30,430
建于油漆编辑器。

57
00:02:30,430 --> 00:02:35,240
您可以上传自己的图像，使用Scratch的内置

58
00:02:35,240 --> 00:02:38,590
的，最后的选择，得到一个随机的精灵。

59
00:02:38,590 --> 00:02:41,760
现在，如果你感觉特别幸运的话，我

60
00:02:41,760 --> 00:02:45,120
欢迎您来试试你的运气，并创建一个随机的精灵。

61
00:02:48,680 --> 00:02:50,890
>> 因此，所有的精灵都放在

62
00:02:50,890 --> 00:02:52,290
在Scratch的阶段。

63
00:02:52,290 --> 00:02:55,130
阶段 - 我们可以把它当作我们的画布。

64
00:02:55,130 --> 00:02:57,510
因此，所有的精灵都放置在舞台上。

65
00:02:57,510 --> 00:03:02,920
而这个阶段，它的作用是让所有的精灵

66
00:03:02,920 --> 00:03:04,160
走动就可以了。

67
00:03:04,160 --> 00:03:09,380
就像精灵，舞台也有脚本。

68
00:03:09,380 --> 00:03:11,930
所以，这些脚本，他们在舞台上 - 

69
00:03:11,930 --> 00:03:14,230
这是非常有用的时候，说，你有一个脚本，它不

70
00:03:14,230 --> 00:03:17,720
完全涉及到一个具体的精灵，而是

71
00:03:17,720 --> 00:03:20,860
涉及到多个精灵或只是，在一般情况，一些

72
00:03:20,860 --> 00:03:21,870
你想做的事情。

73
00:03:21,870 --> 00:03:25,070
所以，你可以将这些脚本在舞台上，而是和

74
00:03:25,070 --> 00:03:28,010
会稍微好一点的设计。

75
00:03:28,010 --> 00:03:32,680
现在，当你可以拥有多个精灵，这是很好的

76
00:03:32,680 --> 00:03:34,420
记住，你只能有一个阶段。

77
00:03:34,420 --> 00:03:37,820
但阶段也有背景的。

78
00:03:37,820 --> 00:03:40,590
反对的服装，像精灵一样，阶段有

79
00:03:40,590 --> 00:03:41,100
背景。

80
00:03:41,100 --> 00:03:44,340
再次，你可以绘制自己的或上传自己的

81
00:03:44,340 --> 00:03:46,140
图像作为背景使用。

82
00:03:49,770 --> 00:03:54,100
>> 所以，没有任何人有任何问题之前，我们去吗？

83
00:03:54,100 --> 00:03:54,380
OK。

84
00:03:54,380 --> 00:03:56,880
随意打断我的话，在演练过程中，

85
00:03:56,880 --> 00:03:58,780
我很高兴回答你的任何问题。

86
00:04:02,750 --> 00:04:03,230
OK。

87
00:04:03,230 --> 00:04:05,950
所以，当你开始你的精灵程序，你要

88
00:04:05,950 --> 00:04:08,430
做的是你要点击绿色旗帜。

89
00:04:08,430 --> 00:04:10,820
但是，如果你不连接任何此块

90
00:04:10,820 --> 00:04:13,400
在这里，再没有什么实际将要发生。

91
00:04:13,400 --> 00:04:16,450
因为，你看，有什么需要的脚本和舞台

92
00:04:16,450 --> 00:04:20,149
做实际上是对事件做出响应 - 

93
00:04:20,149 --> 00:04:22,360
这就是我们给他们打电话，事件 - 绿色标志

94
00:04:22,360 --> 00:04:23,200
被点击。

95
00:04:23,200 --> 00:04:26,840
所以，你需要将块附加到槽

96
00:04:26,840 --> 00:04:30,270
，绿色环保标志的点击底部的块，然后

97
00:04:30,270 --> 00:04:32,670
程序会知道该怎么做，以及如何应对的

98
00:04:32,670 --> 00:04:35,700
绿色标志被点击。

99
00:04:35,700 --> 00:04:38,180
>> 那么，什么之后呢？

100
00:04:38,180 --> 00:04:43,930
好了，我们在Scratch使用了大量的块，

101
00:04:43,930 --> 00:04:47,150
肉，真的，你的程序就在这些

102
00:04:47,150 --> 00:04:48,000
报表。

103
00:04:48,000 --> 00:04:49,900
所以，这些报表都方便

104
00:04:49,900 --> 00:04:51,270
举办​​的颜色。

105
00:04:51,270 --> 00:04:54,970
你有运动相关的行动，

106
00:04:54,970 --> 00:04:56,930
声音，长相，等等。

107
00:04:56,930 --> 00:04:59,530
所以你可以看到，你可以在它们之间导航

108
00:04:59,530 --> 00:05:02,480
标签临时方案。

109
00:05:02,480 --> 00:05:04,870
因此，虽然你将有围绕它的其他东西，

110
00:05:04,870 --> 00:05:08,520
的语句其实这样做实际上是告诉

111
00:05:08,520 --> 00:05:10,380
精灵或该阶段做一些事情。

112
00:05:10,380 --> 00:05:13,450
相对于只是说，OK，当你做到这一点，

113
00:05:13,450 --> 00:05:16,660
报表实际上包含真正的肉。

114
00:05:19,410 --> 00:05:22,210
比方说，你想只执行一个特定的动作，说

115
00:05:22,210 --> 00:05:26,180
某一件事情发生时，你只希望猫喵。

116
00:05:26,180 --> 00:05:28,430
我们可以利用的布尔值，您已经在

117
00:05:28,430 --> 00:05:29,470
第一讲。

118
00:05:29,470 --> 00:05:32,580
所以，这些表达式计算为

119
00:05:32,580 --> 00:05:34,140
或真或假。

120
00:05:34,140 --> 00:05:37,510
等等这些都是确定从头开始 - 

121
00:05:37,510 --> 00:05:42,360
你看到的角度，在这些块的末尾。

122
00:05:42,360 --> 00:05:45,420
让你拥有各种不同类型的布尔值。

123
00:05:45,420 --> 00:05:49,550
“是最被按下，”2加2

124
00:05:49,550 --> 00:05:53,830
等同于5星，“或”是用户按下某一个键

125
00:05:53,830 --> 00:05:55,510
键盘？“

126
00:05:55,510 --> 00:05:57,210
>> 现在，你可以不使用这些孤单。

127
00:05:57,210 --> 00:06:00,970
你需要做的是结合他们的条件。

128
00:06:00,970 --> 00:06:04,420
这样的条件下从头开始控制“选项卡中。

129
00:06:04,420 --> 00:06:07,350
因此，他们方便有一个小的占位符，

130
00:06:07,350 --> 00:06:10,940
显示块，你需要把它的形状。

131
00:06:10,940 --> 00:06:14,720
因此，根据上下文的情况下，您可以选择

132
00:06:14,720 --> 00:06:17,600
一个布尔值，然后将它放在你的病情。

133
00:06:17,600 --> 00:06:19,570
有你有一个条件语句。

134
00:06:19,570 --> 00:06:23,030
如果你把该块语句，那么你有一个

135
00:06:23,030 --> 00:06:26,980
结构设置，即一旦某个条件得到满足，

136
00:06:26,980 --> 00:06:30,494
在左边，你再执行该语句。

137
00:06:30,494 --> 00:06:31,462
是吗？

138
00:06:31,462 --> 00:06:33,720
>> 学生：如果一个变量代表一个数字，你可以

139
00:06:33,720 --> 00:06:36,302
使用布尔变量里面的，像绿色的，

140
00:06:36,302 --> 00:06:36,790
例如？

141
00:06:36,790 --> 00:06:37,540
ZAMYLA陈：是的，你可以。

142
00:06:37,540 --> 00:06:41,500
您可以通过拖放操作的变量值内

143
00:06:41,500 --> 00:06:42,750
圆形的。

144
00:06:48,820 --> 00:06:52,160
>> 现在，计算机的优势之一是强大的力量

145
00:06:52,160 --> 00:06:54,980
和速度，他们可以执行重复的过程。

146
00:06:54,980 --> 00:07:00,370
因此，而不是，比方说，重复的指令

147
00:07:00,370 --> 00:07:03,020
和一遍又一遍的实际输入 - 

148
00:07:03,020 --> 00:07:05,000
在这种情况下，在Scratch，拖动和删除和

149
00:07:05,000 --> 00:07:05,960
拖放 - 

150
00:07:05,960 --> 00:07:08,750
我们能做些什么是封装在一个循环。

151
00:07:08,750 --> 00:07:11,640
因此，循环可以用于执行

152
00:07:11,640 --> 00:07:14,750
无限与无限循环，或为

153
00:07:14,750 --> 00:07:15,880
设置次数 - 

154
00:07:15,880 --> 00:07:20,800
说，重复“SAY HI”10次，或直至一定

155
00:07:20,800 --> 00:07:22,040
条件是真实的。

156
00:07:22,040 --> 00:07:26,370
所以，你看，从头开始暗示，当

157
00:07:26,370 --> 00:07:29,540
你有一个条件，如“重复，直到”那么唯一的

158
00:07:29,540 --> 00:07:34,760
里面有，将适合的东西是一个布尔值。

159
00:07:34,760 --> 00:07:35,120
好的。

160
00:07:35,120 --> 00:07:38,170
>> 所以，现在，我们知道，我们可以封装重复

161
00:07:38,170 --> 00:07:39,840
内部的循环过程。

162
00:07:39,840 --> 00:07:42,880
你可以看到为什么这样的事情可能不太理想。

163
00:07:42,880 --> 00:07:45,600
它不适合在幻灯片上。

164
00:07:45,600 --> 00:07:48,500
从本质上讲，它只是做同样的事情一遍又一遍

165
00:07:48,500 --> 00:07:49,340
10倍的事实。

166
00:07:49,340 --> 00:07:53,380
移动10步，说：“你好，移动10步，说你好。

167
00:07:53,380 --> 00:07:56,140
所以，现在你可以看到，一旦我们有循环，像

168
00:07:56,140 --> 00:07:58,420
这是好了很多。

169
00:07:58,420 --> 00:08:02,690
它的短，它的体积更小，并且它实际上完成

170
00:08:02,690 --> 00:08:03,610
同样的事情。

171
00:08:03,610 --> 00:08:06,420
现在，在Scratch，这可能没有太大的差别，但

172
00:08:06,420 --> 00:08:08,510
它实际上为您节省一些时间。

173
00:08:12,720 --> 00:08:16,800
>> 所以到变量表达式 - 

174
00:08:16,800 --> 00:08:20,260
实际上，你可以使用变量，并把它们内部的

175
00:08:20,260 --> 00:08:20,930
条件。

176
00:08:20,930 --> 00:08:23,490
表示在那里，你看我们有一个变量叫做

177
00:08:23,490 --> 00:08:26,810
“反击，”我们等同，看是否

178
00:08:26,810 --> 00:08:28,040
这是小于0。

179
00:08:28,040 --> 00:08:30,900
所以变量基本上，我会说，

180
00:08:30,900 --> 00:08:32,330
值的容器。

181
00:08:32,330 --> 00:08:36,330
从无到有，这些类型的值可以是文字或

182
00:08:36,330 --> 00:08:37,390
他们可以是数字。

183
00:08:37,390 --> 00:08:41,860
因此，与这些变量，我们能做些什么与他们是我们

184
00:08:41,860 --> 00:08:42,970
可以设定自己的价值。

185
00:08:42,970 --> 00:08:46,590
因此，在这里的第一实施例中，我们有文本的示例的

186
00:08:46,590 --> 00:08:50,470
包含值“世界，你好！”在第二个例子中，

187
00:08:50,470 --> 00:08:53,220
假设我们已经有一个变量叫做

188
00:08:53,220 --> 00:08:56,020
“反击，”在这种情况下，我们改变了它3。

189
00:08:56,020 --> 00:08:58,170
我们加了3。

190
00:08:58,170 --> 00:09:01,680
然后在最后一个例子中，变量可以被拖动

191
00:09:01,680 --> 00:09:04,320
放在一个布尔表达式。

192
00:09:06,830 --> 00:09:12,200
>> 现在，当你创建一个变量，你必须

193
00:09:12,200 --> 00:09:16,900
决定的是你做的所有的变量

194
00:09:16,900 --> 00:09:19,380
精灵在临时程序，或只是

195
00:09:19,380 --> 00:09:22,710
精灵在其中的细节，你当你选择

196
00:09:22,710 --> 00:09:23,930
该变量。

197
00:09:23,930 --> 00:09:27,480
所以这是一个非常重要的决定。

198
00:09:27,480 --> 00:09:30,100
它真的归结到什么范围，你要的

199
00:09:30,100 --> 00:09:31,200
变量具有。

200
00:09:31,200 --> 00:09:35,170
因此，例如，本地范围内的一个例子是，如果你

201
00:09:35,170 --> 00:09:38,370
此精灵只选择有变量。

202
00:09:38,370 --> 00:09:43,250
因此，这将意味着，雪碧，只有将能够

203
00:09:43,250 --> 00:09:44,440
访问该变量。

204
00:09:44,440 --> 00:09:46,670
只有将能够看到它，雪碧，

205
00:09:46,670 --> 00:09:48,020
改变它，修改它。

206
00:09:48,020 --> 00:09:49,910
如果你有一个全球范围的选择 - 

207
00:09:49,910 --> 00:09:52,520
所以，如果你说所有的精灵，

208
00:09:52,520 --> 00:09:53,960
你选择了该选项 - 

209
00:09:53,960 --> 00:09:57,780
那么这意味着的阶段，以及所有精灵

210
00:09:57,780 --> 00:10:01,350
可以看到，修改和访问该变量，

211
00:10:01,350 --> 00:10:04,420
你所创建的。

212
00:10:04,420 --> 00:10:07,080
任何问题，所以对变量或什么？

213
00:10:07,080 --> 00:10:08,674
是。

214
00:10:08,674 --> 00:10:11,248
>> 学生的变量，你可以有两个变量

215
00:10:11,248 --> 00:10:14,300
相同的名称，如果他们是在不同的精灵吗？

216
00:10:14,300 --> 00:10:16,370
ZAMYLA议员：只要他们是本地的精灵---

217
00:10:18,870 --> 00:10:20,700
啊，是的，对不起。

218
00:10:20,700 --> 00:10:24,010
所以，问题是你是否可以有两个变量

219
00:10:24,010 --> 00:10:28,890
相同名称的一个程序，如果你有两个变量，

220
00:10:28,890 --> 00:10:32,760
的名称相同，但都是局部的精灵，精灵之一，

221
00:10:32,760 --> 00:10:36,070
猫，有一个变量名“反”，和精灵两种，

222
00:10:36,070 --> 00:10:38,870
狗，有一个变量名为“反”，只要这些

223
00:10:38,870 --> 00:10:43,040
都是局部的精灵，那么他们的范围不延伸到

224
00:10:43,040 --> 00:10:44,540
其余的程序。

225
00:10:44,540 --> 00:10:47,080
所以没有其他的子图形或

226
00:10:47,080 --> 00:10:48,360
阶段会感到困惑。

227
00:10:53,860 --> 00:10:54,210
好的。

228
00:10:54,210 --> 00:10:58,230
>> 所以，我前面提到的入口点时，我们有

229
00:10:58,230 --> 00:11:01,560
当绿色标记的点击块。

230
00:11:01,560 --> 00:11:05,350
还等什么，那就是 - 

231
00:11:05,350 --> 00:11:08,880
它说，OK，当事件发生时，绿色的标志是

232
00:11:08,880 --> 00:11:11,450
点击，这是你应该做的。

233
00:11:11,450 --> 00:11:13,220
所以这实际上是不可能的唯一事件

234
00:11:13,220 --> 00:11:14,380
我们有划痕。

235
00:11:14,380 --> 00:11:16,060
我们也有其他的事件。

236
00:11:16,060 --> 00:11:18,320
因此，我们有，例如，当一个键

237
00:11:18,320 --> 00:11:19,290
键盘被按下。

238
00:11:19,290 --> 00:11:23,660
实际上，你可以选择字母A到Z，0

239
00:11:23,660 --> 00:11:27,270
到9，或使用箭头键。

240
00:11:27,270 --> 00:11:30,770
然后我们也有其他的事件，比如当你的

241
00:11:30,770 --> 00:11:33,150
精灵被点击。

242
00:11:33,150 --> 00:11:36,590
因此，当你开始，你发现的主要趋势

243
00:11:36,590 --> 00:11:38,950
是，他们只有在底部的槽，所以

244
00:11:38,950 --> 00:11:42,950
然后，再次，钥匙，没有什么高度以上

245
00:11:42,950 --> 00:11:43,640
该数据块。

246
00:11:43,640 --> 00:11:48,770
您打造而成，并在下面。

247
00:11:48,770 --> 00:11:53,040
>> 现在，说会发生什么，如果我们想一些事件的发生只是

248
00:11:53,040 --> 00:11:58,200
猫接触的某一部分的时候，我不知道，

249
00:11:58,200 --> 00:11:59,830
在舞台上或类似的东西？

250
00:11:59,830 --> 00:12:02,420
实际上，我们没有任何内置的

251
00:12:02,420 --> 00:12:04,410
表示事件。

252
00:12:04,410 --> 00:12:07,850
那么，我们将不得不这样做，实际上是创建我们自己的事件。

253
00:12:07,850 --> 00:12:09,950
这就是所谓的广播。

254
00:12:09,950 --> 00:12:13,070
所以，当你想要的信号，一定发生了什么，

255
00:12:13,070 --> 00:12:16,910
然后你使用 - 控制“选项卡中，有一个块称为

256
00:12:16,910 --> 00:12:20,400
“广播”。这样的话，你将键入的名称

257
00:12:20,400 --> 00:12:24,990
要广播的事件，然后为准

258
00:12:24,990 --> 00:12:26,350
精灵精灵 - 

259
00:12:26,350 --> 00:12:28,640
此消息的反应，你可以有多个精灵 - 

260
00:12:28,640 --> 00:12:31,460
或该阶段将有处理，有

261
00:12:31,460 --> 00:12:34,970
收到的话，会说，OK，我明白，这有

262
00:12:34,970 --> 00:12:37,850
发生了什么，所以我打算用它来做到这一点。

263
00:12:37,850 --> 00:12:40,850
所以每当你播放的事件，这是与

264
00:12:40,850 --> 00:12:44,870
理解，要么是精灵或其他精灵

265
00:12:44,870 --> 00:12:47,860
要接收该事件，并回应。

266
00:12:52,610 --> 00:12:55,710
>> 现在，最后的概念，在我们进入一个实际的例子

267
00:12:55,710 --> 00:12:58,390
在擦除程序是线程。

268
00:12:58,390 --> 00:13:02,110
所以当您的电脑执行的线程

269
00:13:02,110 --> 00:13:04,320
在相同的时间的同步进程。

270
00:13:04,320 --> 00:13:06,940
我向你保证，我们所有的人都冤大头

271
00:13:06,940 --> 00:13:09,810
当我们在看电影的同时线程

272
00:13:09,810 --> 00:13:11,540
输入一篇文章，或类似的东西。

273
00:13:11,540 --> 00:13:14,020
计算机执行相同的几件事情

274
00:13:14,020 --> 00:13:17,480
时间，就像从头开始。

275
00:13:17,480 --> 00:13:22,060
所以，你可以看到在这个例子中，这两个脚本

276
00:13:22,060 --> 00:13:25,460
用于完全相同的精灵，因为这些

277
00:13:25,460 --> 00:13:27,590
开始可以实际使用的入口点块

278
00:13:27,590 --> 00:13:28,840
倍数次。

279
00:13:28,840 --> 00:13:32,570
我向你保证，可能是绿色环保标志的点击块

280
00:13:32,570 --> 00:13:36,890
将是最流行的

281
00:13:36,890 --> 00:13:39,230
在你的程序块。

282
00:13:39,230 --> 00:13:43,500
所以，在这里，我们看到的绿色标志，当被点击时，有

283
00:13:43,500 --> 00:13:47,970
一个过程，以及当绿色标志

284
00:13:47,970 --> 00:13:50,150
点击后，有一个单独的进程。

285
00:13:50,150 --> 00:13:53,650
因此，划痕会同时运行这两个。

286
00:13:53,650 --> 00:13:55,930
因此，使用这些线程，知道你其实可以

287
00:13:55,930 --> 00:13:58,010
有一个以上的入口点 - 

288
00:13:58,010 --> 00:14:00,450
即使是相同的入口点 - 

289
00:14:00,450 --> 00:14:04,340
这将成为非常有用的，如果你想，说，

290
00:14:04,340 --> 00:14:06,290
从彼此不同的任务分开。

291
00:14:10,060 --> 00:14:10,490
好的。

292
00:14:10,490 --> 00:14:17,670
因此，让我们研究一个例子，在擦除程序。

293
00:14:25,790 --> 00:14:26,360
>> OK。

294
00:14:26,360 --> 00:14:29,150
所以我已经做了一个小程序，我们在这里。

295
00:14:29,150 --> 00:14:34,740
所以我只是要点击绿色旗帜，以启动和

296
00:14:34,740 --> 00:14:36,520
它做什么。

297
00:14:36,520 --> 00:14:39,590
因此，我们有一个橙色的鱼在这里 - 

298
00:14:39,590 --> 00:14:41,420
一条鱼精灵 - 

299
00:14:41,420 --> 00:14:47,960
似乎移动，然后重置并返回。

300
00:14:47,960 --> 00:14:49,250
然后我们有一个鲨鱼精灵。

301
00:14:49,250 --> 00:14:51,705
这条鲨鱼的精灵可以移动，它可以旋转，它可以

302
00:14:51,705 --> 00:14:53,180
游来游去。

303
00:14:53,180 --> 00:14:53,520
OK。

304
00:14:53,520 --> 00:14:56,650
所以，这是一种乐趣。

305
00:14:56,650 --> 00:15:00,750
但我们可以肯定添加更多。

306
00:15:00,750 --> 00:15:05,790
例如，我们可以看到，当鲨鱼是，它可以

307
00:15:05,790 --> 00:15:07,740
下车的画面，几乎

308
00:15:07,740 --> 00:15:11,150
从视线中消失。

309
00:15:11,150 --> 00:15:13,010
因此，我们要改变这种状况，因为我们不希望

310
00:15:13,010 --> 00:15:14,610
鲨鱼逃跑。

311
00:15:14,610 --> 00:15:19,840
因此，让我们停止我们的脚本，然后编辑鲨鱼

312
00:15:19,840 --> 00:15:22,720
脚本，也许需要添加一些东西。

313
00:15:22,720 --> 00:15:27,400
请注意，在这个特殊的精灵在这里，永远的循环

314
00:15:27,400 --> 00:15:29,160
用一个直边的端部。

315
00:15:29,160 --> 00:15:30,920
它不具有任何凹槽。

316
00:15:30,920 --> 00:15:34,410
所以，事实上，这是有道理的，因为它是一个无限循环。

317
00:15:34,410 --> 00:15:37,430
它执行的东西无限。

318
00:15:37,430 --> 00:15:40,240
所以，它永远不会结束。

319
00:15:40,240 --> 00:15:41,810
即使有，将它下面的东西

320
00:15:41,810 --> 00:15:43,030
从来没有到。

321
00:15:43,030 --> 00:15:49,000
所以，你实际上是被迫推出一个线程。

322
00:15:49,000 --> 00:15:49,500
>> 好的。

323
00:15:49,500 --> 00:15:52,490
因此，让我们添加另一个脚本。

324
00:15:52,490 --> 00:15:55,210
所以，我要开始这个入口点时，绿色

325
00:15:55,210 --> 00:15:56,850
标志被点击。

326
00:15:56,850 --> 00:16:04,900
所以我想要做的是不断地检查是否

327
00:16:04,900 --> 00:16:07,210
鲨鱼将要接触的边缘。

328
00:16:07,210 --> 00:16:10,560
但我知道，其实，运动下有一个整洁的

329
00:16:10,560 --> 00:16:16,170
有点堵，说，哦，如果边缘反弹。

330
00:16:16,170 --> 00:16:18,930
所以我们想要做的是不断执行。

331
00:16:18,930 --> 00:16:22,010
因此，这是什么“，如果边缘，跳出”不 - 它实际上

332
00:16:22,010 --> 00:16:26,170
已检查，如果我上的优势，然后反弹回来。

333
00:16:26,170 --> 00:16:31,770
因此，我们需要找到某种循环不断

334
00:16:31,770 --> 00:16:34,350
执行这条语句。

335
00:16:34,350 --> 00:16:37,360
因此，如果我们看看在控制之下，没有任何人有一个想法，

336
00:16:37,360 --> 00:16:42,060
什么样的循环中，我们可能要使用吗？

337
00:16:42,060 --> 00:16:42,530
是啊。

338
00:16:42,530 --> 00:16:43,470
>> 学生：永远回路。

339
00:16:43,470 --> 00:16:44,300
ZAMYLA陈：是的，是的。

340
00:16:44,300 --> 00:16:45,080
无限循环。

341
00:16:45,080 --> 00:16:48,370
因此，让我们的跟踪，在这里，然后说，如果在边缘反弹。

342
00:16:48,370 --> 00:16:51,580
然后让我们来看看。

343
00:16:51,580 --> 00:16:52,120
好的。

344
00:16:52,120 --> 00:16:54,460
所以鱼是按往常一样。

345
00:16:54,460 --> 00:16:55,540
然后，哦 - 

346
00:16:55,540 --> 00:17:00,280
现在的鲨鱼无法逃脱，反弹的屏幕。

347
00:17:00,280 --> 00:17:01,155
酷。

348
00:17:01,155 --> 00:17:01,600
好的。

349
00:17:01,600 --> 00:17:02,770
所以我往里看。

350
00:17:02,770 --> 00:17:03,710
我不能做到这 - 是吗？

351
00:17:03,710 --> 00:17:06,196
>> 学生：你是如何作出这样的鲨鱼，因为它适用于移动

352
00:17:06,196 --> 00:17:07,329
对鱼？

353
00:17:07,329 --> 00:17:07,780
ZAMYLA陈：啊。

354
00:17:07,780 --> 00:17:15,910
因此，只鲨鱼反弹的原因，而不是

355
00:17:15,910 --> 00:17:20,530
鱼好，是因为我们写的脚本里面

356
00:17:20,530 --> 00:17:21,290
的鲨鱼精灵。

357
00:17:21,290 --> 00:17:22,950
你看，在这里，鲨鱼精灵被选中。

358
00:17:25,609 --> 00:17:25,990
好的。

359
00:17:25,990 --> 00:17:30,730
因此，让我们添加一些东西。

360
00:17:30,730 --> 00:17:34,260
我正在探索不同的服饰，

361
00:17:34,260 --> 00:17:37,870
从无到有，我看到这个可爱的小鲨鱼格格。

362
00:17:37,870 --> 00:17:41,070
所以我想，嘿，好了，也许我们可以实现的

363
00:17:41,070 --> 00:17:45,975
鲨鱼摩拳擦掌，例如，当我们按下空格。

364
00:17:45,975 --> 00:17:47,560
我只是要停止。

365
00:17:47,560 --> 00:17:49,990
好的。

366
00:17:49,990 --> 00:17:50,476
是。

367
00:17:50,476 --> 00:17:54,370
>> 学生：你能不能显示 - 是，在服装？

368
00:17:54,370 --> 00:17:54,900
ZAMYLA陈：哦，是的。

369
00:17:54,900 --> 00:17:59,560
于是我就根据服装，然后我看了下进口。

370
00:17:59,560 --> 00:18:02,780
所以在这里，从无到有整个阵列的服装，

371
00:18:02,780 --> 00:18:03,500
你可以选择。

372
00:18:03,500 --> 00:18:07,120
这样的话有一大堆的动物，然后在

373
00:18:07,120 --> 00:18:09,560
鲨鱼有一对夫妇与它相关的服装。

374
00:18:15,116 --> 00:18:15,580
OK。

375
00:18:15,580 --> 00:18:22,480
因此，在这个脚本在这里，我已经检查不断

376
00:18:22,480 --> 00:18:26,090
在无限循环，OK，好了，如果按下左箭头，

377
00:18:26,090 --> 00:18:28,720
然后，我想逆时针旋转。

378
00:18:28,720 --> 00:18:32,180
如果按下右箭头，我想顺时针旋转。

379
00:18:32,180 --> 00:18:33,800
如果按向上箭头，然后我

380
00:18:33,800 --> 00:18:36,050
要向前发展。

381
00:18:36,050 --> 00:18:42,250
所以我们可以做的仅仅是添加到这个脚本，而不是

382
00:18:42,250 --> 00:18:45,350
加入一个单独的一个，因为这是已经检查

383
00:18:45,350 --> 00:18:48,640
哪个键被按下的主题。

384
00:18:48,640 --> 00:18:52,050
>> 因此，让我们添加一个说，如果空格键 - 让我们使用

385
00:18:52,050 --> 00:18:54,200
空格键格格下来。

386
00:18:54,200 --> 00:18:58,970
因此，这些键按下左箭头，等等，这些都是

387
00:18:58,970 --> 00:19:00,680
在明亮的蓝色。

388
00:19:00,680 --> 00:19:04,520
所以，让我们感明亮的蓝色，和看不起。

389
00:19:04,520 --> 00:19:09,020
哦，这里是按下一个键的空间。

390
00:19:09,020 --> 00:19:13,510
所以我们想要做的是有鲨鱼的开关，其

391
00:19:13,510 --> 00:19:15,320
摩拳擦掌下来的服装。

392
00:19:15,320 --> 00:19:16,670
做有多大的鲨鱼

393
00:19:16,670 --> 00:19:18,160
看起来，所以我们去的外观。

394
00:19:18,160 --> 00:19:21,560
在这里，我们方便，切换到

395
00:19:21,560 --> 00:19:23,680
服装鲨鱼格格。

396
00:19:23,680 --> 00:19:27,980
但是，当我们格格下来，我们不希望鲨鱼

397
00:19:27,980 --> 00:19:30,820
永远叼着下来，所以让我们添加，OK，那么，

398
00:19:30,820 --> 00:19:36,950
它一年要吃掉后，我们希望它切换回。

399
00:19:36,950 --> 00:19:41,790
OK，让我们来看看这是什么做的。

400
00:19:41,790 --> 00:19:43,990
因此，我们把它四处走动。

401
00:19:43,990 --> 00:19:44,720
OK。

402
00:19:44,720 --> 00:19:46,660
因此，我们有摩拳擦掌。

403
00:19:46,660 --> 00:19:51,240
虽然这是摩拳擦掌种迅速，因为在刮，

404
00:19:51,240 --> 00:19:53,710
它的执行瞬间。

405
00:19:53,710 --> 00:19:58,300
那么，让我们去控制，使其体会到它的

406
00:19:58,300 --> 00:19:59,785
格格，等待一秒钟。

407
00:20:03,890 --> 00:20:09,130
在这里，一年要吃掉了一个小更长的时间才能进入

408
00:20:09,130 --> 00:20:11,180
备份到它的饥饿。

409
00:20:11,180 --> 00:20:11,530
>> OK。

410
00:20:11,530 --> 00:20:13,210
所以，我很满意现在的鲨鱼。

411
00:20:13,210 --> 00:20:18,740
但鱼，它似乎是在做什么 - 它的进展

412
00:20:18,740 --> 00:20:20,750
几个步骤中，在事实上，五次。

413
00:20:20,750 --> 00:20:24,940
它的移动50步。

414
00:20:24,940 --> 00:20:29,280
然后，它在做什么在这里这顶块是我

415
00:20:29,280 --> 00:20:35,180
说，OK，好了，它会去到某一定值的x。

416
00:20:35,180 --> 00:20:38,560
要查找的坐标，你可以实际上只是鼠标移到

417
00:20:38,560 --> 00:20:40,550
屏幕上，并且然后在下方 - 

418
00:20:40,550 --> 00:20:41,530
在这里权 - 

419
00:20:41,530 --> 00:20:43,210
它会告诉你的坐标是什么。

420
00:20:43,210 --> 00:20:45,950
所以，你可以利用这一点来输入坐标

421
00:20:45,950 --> 00:20:46,830
你想要的。

422
00:20:46,830 --> 00:20:49,160
因此，这句话是说的是什么说，OK，

423
00:20:49,160 --> 00:20:54,200
，鱼开始在这个特定的x值，然后在

424
00:20:54,200 --> 00:20:55,540
它的高度可以改变的。

425
00:20:55,540 --> 00:20:59,740
实际上，我选择一个随机的高度仍然保持

426
00:20:59,740 --> 00:21:02,580
的限制范围内的阶段。

427
00:21:02,580 --> 00:21:04,320
所以在这里，我利用的是

428
00:21:04,320 --> 00:21:05,680
广播事件。

429
00:21:05,680 --> 00:21:09,310
所以你看，这个事件处理程序是新fish1。

430
00:21:09,310 --> 00:21:14,730
所以，每当鱼接收新fish1事件，它会

431
00:21:14,730 --> 00:21:16,250
执行此。

432
00:21:16,250 --> 00:21:19,740
然后你看到后向前移动，其数额

433
00:21:19,740 --> 00:21:21,400
次，然后它实际上广播

434
00:21:21,400 --> 00:21:22,720
再一次，OK，新的fish1。

435
00:21:25,560 --> 00:21:31,860
但相反，怎么样让我们做它让鱼只

436
00:21:31,860 --> 00:21:35,320
继续在屏幕前复位，

437
00:21:35,320 --> 00:21:37,180
而不是仅仅去种它的中心。

438
00:21:40,480 --> 00:21:46,180
所以不是说，重复5次 - 因为我们不

439
00:21:46,180 --> 00:21:48,380
真正知道多少次，直到它需要

440
00:21:48,380 --> 00:21:52,180
到达终点的画面，让我们用别的。

441
00:21:52,180 --> 00:21:54,870
>> 所以我要分开了这一点，因为我们

442
00:21:54,870 --> 00:21:56,080
真的不希望这样。

443
00:21:56,080 --> 00:21:59,610
在Scratch删除块，你要做的就是你只需要拖动

444
00:21:59,610 --> 00:22:03,415
它的左侧，发布，然后它就会被删除。

445
00:22:03,415 --> 00:22:05,470
如果你决定，你不想这样做，那么你就可以

446
00:22:05,470 --> 00:22:08,970
永远取消删除。

447
00:22:08,970 --> 00:22:10,640
但是，我们要摆脱这种。

448
00:22:10,640 --> 00:22:15,490
我们想要做的是，我们要保持移动50步，

449
00:22:15,490 --> 00:22:19,400
暂停一秒钟，直到我们触摸的屏幕。

450
00:22:19,400 --> 00:22:25,480
因此，任何人都可以发现一个循环，我们可能要使用

451
00:22:25,480 --> 00:22:28,750
重复过程，直到我们触摸屏幕。

452
00:22:31,594 --> 00:22:33,490
>> 学生：重复以上步骤直到。

453
00:22:33,490 --> 00:22:36,750
ZAMYLA陈：我听说“重复，直到”，这是正确的。

454
00:22:36,750 --> 00:22:40,990
所以，这种重复，直到块也需要 - 

455
00:22:40,990 --> 00:22:43,770
但我们看到，这种重复，直到块是不是很

456
00:22:43,770 --> 00:22:44,570
完整的，对不对？

457
00:22:44,570 --> 00:22:48,490
因此，我们必须说，OK，好了，重复到什么时候？

458
00:22:48,490 --> 00:22:51,380
所以我们说，好了，好了，重复，直到鱼接触

459
00:22:51,380 --> 00:22:52,680
在屏幕的边缘。

460
00:22:52,680 --> 00:22:55,230
所以，我会告诉你，这是根据检测。

461
00:22:55,230 --> 00:22:58,930
这感人的布尔值。

462
00:22:58,930 --> 00:23:04,510
所以你可以在这里选择你想要检查

463
00:23:04,510 --> 00:23:05,530
鱼是感人的。

464
00:23:05,530 --> 00:23:09,200
所以在这里，我们想说感人的边缘。

465
00:23:09,200 --> 00:23:13,110
然后，我们要添加这回英寸

466
00:23:13,110 --> 00:23:21,940
所以现在，如果我们看我们的鱼，一旦接触

467
00:23:21,940 --> 00:23:25,170
边缘，它会重新移回。

468
00:23:25,170 --> 00:23:25,660
好的。

469
00:23:25,660 --> 00:23:27,390
因此，我很高兴。

470
00:23:27,390 --> 00:23:30,890
让我们打开HungryShark1。

471
00:23:34,620 --> 00:23:38,230
>> OK，有点像一个烹饪节目，我一点点

472
00:23:38,230 --> 00:23:39,850
更多的功能。

473
00:23:39,850 --> 00:23:43,080
因此，举例来说，你看，现在的鱼实际上是

474
00:23:43,080 --> 00:23:45,960
滑翔相当顺利，而不是之前，当它是

475
00:23:45,960 --> 00:23:48,350
种移动和停止，移动和停止 - 

476
00:23:48,350 --> 00:23:52,890
本质上只是跳跃的一组像素。

477
00:23:52,890 --> 00:23:56,810
我看了下运动，该滑翔声明，然后我

478
00:23:56,810 --> 00:24:00,515
说，OK，而不是只移动和停止，移动

479
00:24:00,515 --> 00:24:04,850
和停止，我将下滑70个单位的权利，

480
00:24:04,850 --> 00:24:08,500
但留在我的相同的Y位置。

481
00:24:08,500 --> 00:24:09,680
好的。

482
00:24:09,680 --> 00:24:11,430
因此，我们有鲨鱼，可以格格。

483
00:24:13,940 --> 00:24:15,060
酷。

484
00:24:15,060 --> 00:24:18,610
但它被称为HungryShark的，毕竟，让我们有

485
00:24:18,610 --> 00:24:20,550
鲨鱼吃的鱼。

486
00:24:20,550 --> 00:24:29,120
>> 因此，我们怎么可能告诉鱼，或告诉鲨鱼，它有

487
00:24:29,120 --> 00:24:30,680
chomped下来吗？

488
00:24:30,680 --> 00:24:32,470
我们该如​​何沟通？

489
00:24:32,470 --> 00:24:33,220
是。

490
00:24:33,220 --> 00:24:35,120
学生：在服装的鲨鱼，

491
00:24:35,120 --> 00:24:36,550
它捕获的鱼。

492
00:24:36,550 --> 00:24:38,460
ZAMYLA陈：是的，没错。

493
00:24:38,460 --> 00:24:42,710
因此，我们知道，当我们切换服装

494
00:24:42,710 --> 00:24:45,500
格格，我们有格格下来。

495
00:24:45,500 --> 00:24:49,530
现在，我们最终将不得不进行检查。

496
00:24:49,530 --> 00:24:51,880
假设我们要消失，一旦它吃的鱼。

497
00:24:51,880 --> 00:24:54,820
我们必须以某种方式沟通的鱼

498
00:24:54,820 --> 00:24:59,405
它会隐藏，例如，或消失

499
00:24:59,405 --> 00:25:01,670
屏幕上，一旦它被chomped下来。

500
00:25:01,670 --> 00:25:08,200
>> 那么什么样的概念，什么样的工具我们可以使用

501
00:25:08,200 --> 00:25:10,440
有鲨鱼的鱼沟通，OK，

502
00:25:10,440 --> 00:25:11,526
我chomped了？

503
00:25:11,526 --> 00:25:12,340
学生：“广播。

504
00:25:12,340 --> 00:25:14,290
ZAMYLA陈：是的，确切地说，广播的事件。

505
00:25:14,290 --> 00:25:17,733
因此，让我们去控制，让我们说广播。

506
00:25:20,280 --> 00:25:24,730
让我们的广播格格。

507
00:25:24,730 --> 00:25:25,420
好的。

508
00:25:25,420 --> 00:25:27,690
但是，一旦我们播出了，这是与

509
00:25:27,690 --> 00:25:29,390
假设，我们实际上要的东西

510
00:25:29,390 --> 00:25:30,360
接受它。

511
00:25:30,360 --> 00:25:32,110
并使得将是鱼。

512
00:25:32,110 --> 00:25:36,600
因此，让我们说，当我收到格格。

513
00:25:40,360 --> 00:25:43,720
现在，当鲨鱼格格下降只是一个空的空间，我们不

514
00:25:43,720 --> 00:25:46,180
要的鱼，在所有的反应。

515
00:25:46,180 --> 00:25:50,780
因此，让我们说，OK，很好，只有当鲨鱼接触

516
00:25:50,780 --> 00:25:52,310
鱼的格格时间 - 

517
00:25:52,310 --> 00:25:54,210
那个时候，我们会做一些事情。

518
00:25:54,210 --> 00:25:58,560
那么，我们如果使用的条件，权利，

519
00:25:58,560 --> 00:26:01,100
因为我们要检查东西是否是真还是假。

520
00:26:01,100 --> 00:26:03,170
因此，如果我们回去检测，然后我们就可以

521
00:26:03,170 --> 00:26:05,760
在这里使用，如果接触。

522
00:26:05,760 --> 00:26:07,490
那么在这里，我们将选择鲨鱼。

523
00:26:12,280 --> 00:26:14,710
然后在看起来，这个隐藏版块 - 

524
00:26:14,710 --> 00:26:19,250
会的鱼基本上是从舞台上消失。

525
00:26:19,250 --> 00:26:22,760
我们将它隐藏，但我们希望另一条鱼，对不对？

526
00:26:22,760 --> 00:26:23,820
我们的鲨鱼是饿了。

527
00:26:23,820 --> 00:26:24,960
我们想给它更多的鱼。

528
00:26:24,960 --> 00:26:31,640
那么，让我们也再次播出的新鱼。

529
00:26:31,640 --> 00:26:31,890
OK。

530
00:26:31,890 --> 00:26:35,880
所以，让我们来看看这是什么做的。

531
00:26:35,880 --> 00:26:36,310
>> 酷。

532
00:26:36,310 --> 00:26:38,830
因此，它一年要吃掉另一条鱼出现。

533
00:26:38,830 --> 00:26:41,360
但是，这是一个有点太快了另一条鱼去。

534
00:26:41,360 --> 00:26:44,610
因此，让我们等待一秒钟，然后我们

535
00:26:44,610 --> 00:26:45,860
播出的新鱼。

536
00:26:48,350 --> 00:26:49,110
好的。

537
00:26:49,110 --> 00:26:49,380
OK。

538
00:26:49,380 --> 00:26:52,460
因此，这是一个很好的制作的游戏。

539
00:26:52,460 --> 00:26:54,350
但是，所有的游戏都需要的分数，对不对？

540
00:26:54,350 --> 00:26:57,070
所以，我们可以用什么保持得分吗？

541
00:27:00,370 --> 00:27:00,630
是。

542
00:27:00,630 --> 00:27:01,005
学生：其他 - 

543
00:27:01,005 --> 00:27:01,830
ZAMYLA陈：是的。

544
00:27:01,830 --> 00:27:02,290
没错。

545
00:27:02,290 --> 00:27:04,520
是啊。

546
00:27:04,520 --> 00:27:06,480
所以，我们要跟踪基本上是如何

547
00:27:06,480 --> 00:27:07,660
许多鱼吃掉了。

548
00:27:07,660 --> 00:27:09,430
要做到这一点，我们必须使一个变量。

549
00:27:09,430 --> 00:27:11,100
让我们打电话，得分。

550
00:27:11,100 --> 00:27:14,240
因此推测，因为这是我们玩的游戏，

551
00:27:14,240 --> 00:27:18,060
我们希望能够鱼 - 

552
00:27:18,060 --> 00:27:19,860
也就是说，一旦吃了可以增加分数或

553
00:27:19,860 --> 00:27:23,780
的东西，然后阶段可能会做

554
00:27:23,780 --> 00:27:25,020
以及疼痛的的东西。

555
00:27:25,020 --> 00:27:28,280
所以，我要选择，这是一个全局变量，并说

556
00:27:28,280 --> 00:27:30,920
所有的精灵。

557
00:27:30,920 --> 00:27:31,470
OK。

558
00:27:31,470 --> 00:27:33,880
因此，当我们要增加得分呢？

559
00:27:33,880 --> 00:27:36,440
当一条鱼被吃掉了。

560
00:27:36,440 --> 00:27:39,390
因此，我们已经有一个过程的处理

561
00:27:39,390 --> 00:27:40,800
被吃掉的鱼。

562
00:27:40,800 --> 00:27:43,570
因此，让我们在这里添加此语句 - 

563
00:27:43,570 --> 00:27:44,820
更改分数1。

564
00:27:49,208 --> 00:27:49,670
酷。

565
00:27:49,670 --> 00:27:54,580
所以，一旦你吃一条鱼，得分增加。

566
00:27:54,580 --> 00:27:54,790
>> 好的。

567
00:27:54,790 --> 00:27:57,090
所以说，我厌倦了这个游戏。

568
00:27:57,090 --> 00:27:58,410
我停下来。

569
00:27:58,410 --> 00:28:01,110
然后，哦，我想回来的游戏。

570
00:28:01,110 --> 00:28:02,630
我要开始一个新的游戏。

571
00:28:02,630 --> 00:28:05,550
，将比分是3，即使我

572
00:28:05,550 --> 00:28:06,680
玩一个新游戏。

573
00:28:06,680 --> 00:28:10,190
我们真的不希望的得分从来没有复位，对不对？

574
00:28:10,190 --> 00:28:16,240
因此，让我们在游戏开始时添加一条语句

575
00:28:16,240 --> 00:28:19,990
上演说，OK，好了，我们要重设的得分。

576
00:28:19,990 --> 00:28:23,100
所以在这里，我们设置变量的得分为0。

577
00:28:23,100 --> 00:28:27,960
所以现在，当你开始一场比赛中，得分

578
00:28:27,960 --> 00:28:30,920
从0开始。

579
00:28:30,920 --> 00:28:32,270
酷。

580
00:28:32,270 --> 00:28:33,520
OK。

581
00:28:36,875 --> 00:28:37,340
OK。

582
00:28:37,340 --> 00:28:40,240
所以，现在，让我们去到HungryShark2。

583
00:28:40,240 --> 00:28:43,500
>> 所以我做了一点点现在，我做了什么

584
00:28:43,500 --> 00:28:44,860
右键单击鱼精灵。

585
00:28:44,860 --> 00:28:47,970
我希望更多的鱼，所以我点击重复，并做出了

586
00:28:47,970 --> 00:28:51,930
一个新的sprite相同的一个，也被复制在所有的

587
00:28:51,930 --> 00:28:53,030
脚本。

588
00:28:53,030 --> 00:28:56,810
那么这fish2基本上是相同的

589
00:28:56,810 --> 00:28:59,630
fish1，除了代替从左边开始

590
00:28:59,630 --> 00:29:02,550
向右移动，它开始在右向左移动。

591
00:29:02,550 --> 00:29:06,390
然后，我也选择了新的服装。

592
00:29:06,390 --> 00:29:09,022
然后，我发现了另一个服装，这是一个斑鱼，和我

593
00:29:09,022 --> 00:29:11,950
很喜欢，凉爽，这看起来有毒的，所以让我们假装

594
00:29:11,950 --> 00:29:13,600
这是一种有毒的鱼。

595
00:29:13,600 --> 00:29:18,250
所以我说，OK，好了，而不是吃

596
00:29:18,250 --> 00:29:20,980
有毒的鱼和增加你的分数，其实我

597
00:29:20,980 --> 00:29:22,210
要减少。

598
00:29:22,210 --> 00:29:27,890
所以在这里我们得分下降1时

599
00:29:27,890 --> 00:29:29,990
鲨鱼吃它。

600
00:29:29,990 --> 00:29:31,650
然后，我真的很喜欢的服装，刮刮

601
00:29:31,650 --> 00:29:34,450
，我看了看，然后我发现shark's  - 

602
00:29:34,450 --> 00:29:36,050
它看起来像一个生病的鲨鱼。

603
00:29:36,050 --> 00:29:38,040
这样的话，我编辑它，我把它绿色。

604
00:29:38,040 --> 00:29:41,880
和我一样，冷静，这是一个生病的鲨鱼。

605
00:29:41,880 --> 00:29:42,150
好的。

606
00:29:42,150 --> 00:29:49,150
>> 因此，让我们，让我们添加到我们的脚本某种方式，使

607
00:29:49,150 --> 00:29:53,660
鲨鱼切换到生病时，它

608
00:29:53,660 --> 00:29:56,800
吃了中毒的鱼。

609
00:29:56,800 --> 00:29:57,380
OK。

610
00:29:57,380 --> 00:30:03,620
所以，因为我们复制了所有的脚本，从原来的

611
00:30:03,620 --> 00:30:07,760
毒鱼的成鱼，它已经拥有这个精灵

612
00:30:07,760 --> 00:30:10,680
说，当我chomped了下来，我

613
00:30:10,680 --> 00:30:12,020
其实chomped下来吗？

614
00:30:12,020 --> 00:30:15,660
因此，我们可以利用这一点来传达给

615
00:30:15,660 --> 00:30:18,170
鲨鱼，哦，好了，你刚才吃了毒鱼。

616
00:30:18,170 --> 00:30:18,850
你生病了。

617
00:30:18,850 --> 00:30:23,100
所以这将是什么样的行动呢？

618
00:30:23,100 --> 00:30:25,110
什么会想要做什么？

619
00:30:25,110 --> 00:30:25,650
广播。

620
00:30:25,650 --> 00:30:26,240
是的，没错。

621
00:30:26,240 --> 00:30:28,930
因此，让我们的广播。

622
00:30:28,930 --> 00:30:33,650
让我们称之为鲨鱼生病。

623
00:30:33,650 --> 00:30:34,320
OK。

624
00:30:34,320 --> 00:30:36,930
因此，现在的鲨鱼，很明显，是要成为一个谁的

625
00:30:36,930 --> 00:30:38,250
接收此事件。

626
00:30:38,250 --> 00:30:44,150
因此，让我们来添加，当我收到的鲨鱼生病。

627
00:30:44,150 --> 00:30:44,410
OK。

628
00:30:44,410 --> 00:30:46,300
因此，我们知道我们有这样的服装 - 

629
00:30:46,300 --> 00:30:49,400
鲨鱼是生病了。

630
00:30:49,400 --> 00:30:51,900
那么我们就知道在这之前，我们种欣赏

631
00:30:51,900 --> 00:30:54,420
当我们可以切换回之前暂停一点点。

632
00:30:54,420 --> 00:30:54,875
是吗？

633
00:30:54,875 --> 00:30:56,467
>> 学生：你如何复制脚本

634
00:30:56,467 --> 00:30:57,605
一个精灵吗？

635
00:30:57,605 --> 00:30:58,510
ZAMYLA陈：啊。

636
00:30:58,510 --> 00:31:03,610
因此，在这种情况下，当我刚刚复制的精灵，

637
00:31:03,610 --> 00:31:07,880
一个脚本复制到另一个精灵，我在这里做什么

638
00:31:07,880 --> 00:31:11,630
只是说重复的，它实际上是一个全新的

639
00:31:11,630 --> 00:31:14,110
精灵的所有脚本。

640
00:31:14,110 --> 00:31:18,100
但说你只想一个特定的脚本复制到另一个

641
00:31:18,100 --> 00:31:23,740
精灵，那么你会做什么，其实只是拖动该

642
00:31:23,740 --> 00:31:29,990
将鼠标悬停在另一个脚本，现在在这里重复它。

643
00:31:29,990 --> 00:31:32,590
在这种情况下，它已经有了它，我们就可以删除

644
00:31:32,590 --> 00:31:33,170
再来一次。

645
00:31:33,170 --> 00:31:37,060
但是，复制为另一种语言，你要做的就是

646
00:31:37,060 --> 00:31:40,230
将其拖动到其他的精灵。

647
00:31:40,230 --> 00:31:40,490
OK。

648
00:31:40,490 --> 00:31:42,390
>> 因此，我们在生病的鲨鱼。

649
00:31:42,390 --> 00:31:45,650
因此，它接收到的鲨鱼是生病了，它说，OK，很好，

650
00:31:45,650 --> 00:31:49,110
一次我生病了，我要切换到我的服装说

651
00:31:49,110 --> 00:31:54,630
“鲨鱼生病，”现在，我们只需添加一个等待

652
00:31:54,630 --> 00:31:56,280
欣赏绿色的。

653
00:31:56,280 --> 00:31:59,560
然后，我们要挨饿了，所以我们可以

654
00:31:59,560 --> 00:32:04,140
切换到饥饿的鲨鱼。

655
00:32:04,140 --> 00:32:04,460
好的。

656
00:32:04,460 --> 00:32:06,390
因此，让我们吃紫色的鱼。

657
00:32:06,390 --> 00:32:07,640
这很好。

658
00:32:10,700 --> 00:32:11,230
这个问题问得好。

659
00:32:11,230 --> 00:32:13,070
到柜台发生了什么事？

660
00:32:13,070 --> 00:32:13,660
OK。

661
00:32:13,660 --> 00:32:23,090
因此，我们得分为0，在这里，但这个分数 - 

662
00:32:23,090 --> 00:32:28,700
此选中标记，它隐藏或不隐藏的变量

663
00:32:28,700 --> 00:32:29,775
从屏幕上。

664
00:32:29,775 --> 00:32:34,320
但是，我们能做些什么，而不是取消选中或检查 - 

665
00:32:34,320 --> 00:32:37,330
实际上，我们可以在这里说，此块“显示或隐藏

666
00:32:37,330 --> 00:32:40,160
变量“。因此，让我们确保，我们每次开始

667
00:32:40,160 --> 00:32:41,945
该变量是显示游戏。

668
00:32:44,840 --> 00:32:45,100
>> OK。

669
00:32:45,100 --> 00:32:46,540
因此，现在的变量被示出。

670
00:32:46,540 --> 00:32:52,160
我们吃了毒鱼，和我们生病。

671
00:32:52,160 --> 00:32:53,440
酷。

672
00:32:53,440 --> 00:32:53,680
好的。

673
00:32:53,680 --> 00:32:56,910
所以，现在，这是奇怪的比赛对我们来说有负面

674
00:32:56,910 --> 00:32:57,420
点，对不对？

675
00:32:57,420 --> 00:33:01,830
因此，它一直在吃了这些，就好像 - 

676
00:33:01,830 --> 00:33:05,190
所以怎么样时，我们得到否定的，如果我们已经吃了太多

677
00:33:05,190 --> 00:33:10,770
许多有毒的鱼，游戏结束 - 鲨鱼的太变态了。

678
00:33:10,770 --> 00:33:11,110
好的。

679
00:33:11,110 --> 00:33:12,680
因此，我们需要做的是，我们需要

680
00:33:12,680 --> 00:33:14,950
播出的一些事件 - 

681
00:33:14,950 --> 00:33:15,960
比赛结束了。

682
00:33:15,960 --> 00:33:17,710
因此，我们能做到这几个方面，其实。

683
00:33:17,710 --> 00:33:20,810
我们可以有一个脚本，在舞台上的某处

684
00:33:20,810 --> 00:33:22,920
不断检查是负的成绩？

685
00:33:22,920 --> 00:33:24,030
是负的成绩吗？

686
00:33:24,030 --> 00:33:26,910
如果是的话，那么我们播出此事件。

687
00:33:26,910 --> 00:33:29,120
>> 所以这是做这件事的方法之一。

688
00:33:29,120 --> 00:33:31,640
或者，我们可以利用的事实，我们知道，

689
00:33:31,640 --> 00:33:36,990
只有这样，你的分数可能是负面的是，当你吃了

690
00:33:36,990 --> 00:33:38,360
有毒的鱼，对不对？

691
00:33:38,360 --> 00:33:39,930
因为当你吃另一种鱼，

692
00:33:39,930 --> 00:33:41,240
得分要增加。

693
00:33:41,240 --> 00:33:44,440
因此，有检查它是否应该是没有用的，

694
00:33:44,440 --> 00:33:46,390
游戏结束与否。

695
00:33:46,390 --> 00:33:50,270
因此，这是一个类似的过程。

696
00:33:50,270 --> 00:33:53,230
因此，我们实际上可以添加到这个“当我收到鲨鱼

697
00:33:53,230 --> 00:33:54,700
病了。“

698
00:33:54,700 --> 00:33:59,575
所以说，我们添加了这个条件。

699
00:34:02,080 --> 00:34:04,820
我们想说的是，如果得分小于0。

700
00:34:04,820 --> 00:34:07,480
因此，我们将去运营商，我们将使用

701
00:34:07,480 --> 00:34:09,650
这小于1，我们要拖我们的

702
00:34:09,650 --> 00:34:12,800
得分在这里，说0。

703
00:34:12,800 --> 00:34:16,920
因此，如果得分为0，那么我们要广播

704
00:34:16,920 --> 00:34:20,790
一些所谓的游戏结束了。

705
00:34:23,310 --> 00:34:24,560
>> OK。

706
00:34:26,199 --> 00:34:29,650
所以说，我们有游戏。

707
00:34:29,650 --> 00:34:33,199
让我们在这里的东西。

708
00:34:33,199 --> 00:34:38,739
好了，我们希望鲨鱼才回去感到饿了，如果

709
00:34:38,739 --> 00:34:40,980
本场比赛仍然可以播放。

710
00:34:40,980 --> 00:34:43,909
因此，而不是使用“如果”，我们将使用

711
00:34:43,909 --> 00:34:45,380
“如果其他”。

712
00:34:45,380 --> 00:34:48,060
所以，这是什么 - 它说，OK，所以如果这种情况是

713
00:34:48,060 --> 00:34:51,630
真的话，那么做到这一点，但如果它是假的，那么做到这一点。

714
00:34:51,630 --> 00:34:54,929
因此，让我们添加如果得分小于0，那么你

715
00:34:54,929 --> 00:34:57,730
广播game over了，但如果没有 - 如果你的

716
00:34:57,730 --> 00:34:59,210
比分仍然是积极的 - 

717
00:34:59,210 --> 00:35:00,720
然后回去饥饿。

718
00:35:03,530 --> 00:35:03,790
OK。

719
00:35:03,790 --> 00:35:04,290
酷。

720
00:35:04,290 --> 00:35:09,390
所以，现在，我们有这个游戏结束事件中，我们将有

721
00:35:09,390 --> 00:35:11,040
它的一些方式。

722
00:35:11,040 --> 00:35:16,460
>> 因此，让我们说：“当我收到游戏的一个新的脚本

723
00:35:16,460 --> 00:35:21,470
结束了。“我们有什么在控制这实际上是

724
00:35:21,470 --> 00:35:25,410
停止所有的按钮，所以它基本上模仿你点击

725
00:35:25,410 --> 00:35:26,720
红色的停止在这里签字。

726
00:35:26,720 --> 00:35:30,210
因此，让我们的鲨鱼停止。

727
00:35:30,210 --> 00:35:33,020
因此，我们也希望鱼停止工作，让我们拖动和

728
00:35:33,020 --> 00:35:33,910
复制它。

729
00:35:33,910 --> 00:35:36,830
我们希望所有的鱼停止。

730
00:35:36,830 --> 00:35:39,530
然后让的阶段停止。

731
00:35:39,530 --> 00:35:39,910
好的。

732
00:35:39,910 --> 00:35:43,730
所以，游来游去，我们吃了鱼，

733
00:35:43,730 --> 00:35:46,580
然后该程序冻结。

734
00:35:46,580 --> 00:35:49,670
我一下，但我不能做任何事情。

735
00:35:49,670 --> 00:35:56,500
OK，但让我们说，我们不想提醒用户

736
00:35:56,500 --> 00:36:00,410
他们已经有了一个负值，例如，然后我们就可以，

737
00:36:00,410 --> 00:36:02,820
例如，从屏幕上隐藏的变量。

738
00:36:02,820 --> 00:36:06,340
所以，当阶段比赛结束，然后它会隐藏

739
00:36:06,340 --> 00:36:07,590
的可变得分。

740
00:36:10,714 --> 00:36:12,190
OK。

741
00:36:12,190 --> 00:36:15,025
因此，让我们吃更多的鱼。

742
00:36:19,900 --> 00:36:23,420
然后得分就消失了，你只是有这个屏幕。

743
00:36:23,420 --> 00:36:23,660
>> 好的。

744
00:36:23,660 --> 00:36:26,530
所以这是一个相当不错的游戏，如果你有更多的

745
00:36:26,530 --> 00:36:30,010
时间，那么你最终可能会增加

746
00:36:30,010 --> 00:36:31,590
越来越多的脚本。

747
00:36:31,590 --> 00:36:34,630
这样的话，我增加了一些更多的鱼，使他们进步

748
00:36:34,630 --> 00:36:38,830
以不同的速度，然后每当鲨鱼吃了

749
00:36:38,830 --> 00:36:42,140
有毒的鱼，它实际上说，“布莱赫！”

750
00:36:42,140 --> 00:36:45,010
然后是我做的，是我添加了一个新的背景

751
00:36:45,010 --> 00:36:47,210
阶段 - 在背景的游戏。

752
00:36:47,210 --> 00:36:53,610
因此，在什么阶段比赛结束事件

753
00:36:53,610 --> 00:36:58,100
切换到游戏的背景处理

754
00:36:58,100 --> 00:36:58,880
背景。

755
00:36:58,880 --> 00:37:03,930
以及，我藏的阶段，所以，所有的精灵

756
00:37:03,930 --> 00:37:07,330
只有游戏在背景显示。

757
00:37:07,330 --> 00:37:10,620
有一对夫妇，我添加了其他小增加，

758
00:37:10,620 --> 00:37:14,810
例如，之前，当我们结束了我们的计划，那么，我们的

759
00:37:14,810 --> 00:37:18,370
鲨鱼，接下来的时间，我们才开始，将启动

760
00:37:18,370 --> 00:37:19,620
该位置为好。

761
00:37:19,620 --> 00:37:23,970
我添加的是绿色标志时，点击，然后

762
00:37:23,970 --> 00:37:26,920
鲨鱼“又回到了原点，然后面朝

763
00:37:26,920 --> 00:37:28,490
的权利，让每一次，你有

764
00:37:28,490 --> 00:37:30,270
有鲨鱼出发。

765
00:37:30,270 --> 00:37:32,910
>> 所以，你可以尝试运动之类的东西，

766
00:37:32,910 --> 00:37:37,410
只需添加很少触及，让您的

767
00:37:37,410 --> 00:37:39,820
游戏有点更精致。

768
00:37:39,820 --> 00:37:41,190
有没有人有任何疑问HungryShark？

769
00:37:45,610 --> 00:37:46,050
酷。

770
00:37:46,050 --> 00:37:46,400
好的。

771
00:37:46,400 --> 00:37:49,730
所以这是一个例子的东西，你可以使

772
00:37:49,730 --> 00:37:53,230
从头开始使用所有的工具，我们前面讨论过的。

773
00:37:53,230 --> 00:37:57,530
所以我也包含在演练中的幻灯片。

774
00:37:57,530 --> 00:37:58,460
你会看到它们。

775
00:37:58,460 --> 00:38:01,770
这只是一个概观的过程，我们做了 - 

776
00:38:01,770 --> 00:38:05,130
进展从HungryShark0所有的方式，以我方最后。

777
00:38:05,130 --> 00:38:08,466
一

778
00:38:08,466 --> 00:38:08,960
是啊。

779
00:38:08,960 --> 00:38:10,310
但是，仅此而已。

780
00:38:10,310 --> 00:38:11,690
如果你们想，我会留下

781
00:38:11,690 --> 00:38:12,990
问任何问题。

782
00:38:12,990 --> 00:38:14,060
这是演练0。

783
00:38:14,060 --> 00:38:16,250
谢谢大家的到来，我会看到你在演练1。