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。