1
00:00:00,000 --> 00:00:05,069

2
00:00:05,069 --> 00:00:06,110
Томас ОЖИВЛЕННАЯ: Ладно.

3
00:00:06,110 --> 00:00:07,450
Всем привет.

4
00:00:07,450 --> 00:00:08,690
Я Томас Лайвли.

5
00:00:08,690 --> 00:00:15,160
Этот семинар будет
писать 2D игры в C, используя SDL.

6
00:00:15,160 --> 00:00:17,970
Так что я знаю, что ты все
просить, да, я действительно

7
00:00:17,970 --> 00:00:22,050
хочу играть в игры и делать игры,
но то, что этот бизнес SDL?

8
00:00:22,050 --> 00:00:25,320
Так SDL библиотека С.

9
00:00:25,320 --> 00:00:28,270
Он стоит по той простой
DirectMedia уровня.

10
00:00:28,270 --> 00:00:31,340
И это кросс-платформенный,
игра библиотека разработки.

11
00:00:31,340 --> 00:00:37,160
Она работает на Windows, Mac,
Linux, даже IOS и Android.

12
00:00:37,160 --> 00:00:40,380
Он обрабатывает такие вещи, как
доступ к аудио-систем

13
00:00:40,380 --> 00:00:44,900
для компьютера, клавиатуры, и
мыши, джойстики, если они прикреплены.

14
00:00:44,900 --> 00:00:48,300
На мобильный телефон, он может даже сделать
сенсорный ввод, и все, что.

15
00:00:48,300 --> 00:00:53,030
И, конечно, он обрабатывает графику,
рисунок вещи на экране.

16
00:00:53,030 --> 00:00:56,470
>> Так что это очень широко используется, хотя
Вы, возможно, не слышали о нем раньше.

17
00:00:56,470 --> 00:01:00,860
Он построен в, например,
Источник двигатель от Valve,

18
00:01:00,860 --> 00:01:04,970
который питает такие игры, как
Портал и Team Fortress 2.

19
00:01:04,970 --> 00:01:08,680
Это также в очень большом количестве
инди игр, которые выходят,

20
00:01:08,680 --> 00:01:13,545
так что я рад видеть, что вы
все будет делать с этим.

21
00:01:13,545 --> 00:01:20,000
>> Цели семинара, чтобы вы
установить, чтобы быть развивается SDL.

22
00:01:20,000 --> 00:01:22,700
Мы собираемся узнать, как
создать окно игры.

23
00:01:22,700 --> 00:01:26,130
Мы собираемся создать спрайты,
которые являются изображения в вашей игре

24
00:01:26,130 --> 00:01:27,744
которые могут передвигаться.

25
00:01:27,744 --> 00:01:29,910
Мы собираемся узнать, как
чтобы и анимировать спрайты,

26
00:01:29,910 --> 00:01:32,910
так перемещать их, сделать
их со временем меняться.

27
00:01:32,910 --> 00:01:35,580
И мы собираемся, чтобы узнать, как
захватить клавиатуру и мышь

28
00:01:35,580 --> 00:01:38,240
поступающие с компьютера.

29
00:01:38,240 --> 00:01:41,550
То, что мы не будем говорить
о сегодня 3D-графика,

30
00:01:41,550 --> 00:01:45,520
потому что это очень сложный
предмет, который мы не имеем времени для.

31
00:01:45,520 --> 00:01:49,010
Мы не узнаем, как
играть аудио на наших играх.

32
00:01:49,010 --> 00:01:53,300
И мы не будем строить
для чего, кроме Linux.

33
00:01:53,300 --> 00:01:58,330
>> Теперь предостережения есть, что
Будем надеяться, что к концу года состоялся семинар,

34
00:01:58,330 --> 00:02:01,660
Вы будете комфортно
документация SDL,

35
00:02:01,660 --> 00:02:05,370
так что вы сможете пойти выяснить
как играть аудио для себя.

36
00:02:05,370 --> 00:02:12,150
Также здание для Mac или PC должен работать
точно так же, как строительство для Linux,

37
00:02:12,150 --> 00:02:14,700
но установка собирается
будет немного отличаться.

38
00:02:14,700 --> 00:02:17,700
Таким образом, вы должны быть в состоянии понять
как сделать эти вещи

39
00:02:17,700 --> 00:02:20,900
к концу сегодняшнего семинара.

40
00:02:20,900 --> 00:02:26,980
>> Таким образом, для установки, мы собираемся
использовать виртуальную машину.

41
00:02:26,980 --> 00:02:31,010
Мы хотели бы использовать CS50 IDE, потому что
мы только собираемся, чтобы писать на C.

42
00:02:31,010 --> 00:02:35,120
Но так как IDE не браузер, мы
не могут создавать новые окна или дисплей

43
00:02:35,120 --> 00:02:36,410
графика в ней.

44
00:02:36,410 --> 00:02:38,450
Таким образом, мы должны виртуальную машину.

45
00:02:38,450 --> 00:02:47,790
Таким образом, вы можете следовать инструкциям
здесь manual.CS50.net/appliance/15~~pobj

46
00:02:47,790 --> 00:02:53,290
установить официальное CS50 прибор,
что лишь виртуальный Linux

47
00:02:53,290 --> 00:02:55,110
машина.

48
00:02:55,110 --> 00:02:58,090
>> А потом, как только у вас есть
что все это установить up--

49
00:02:58,090 --> 00:03:02,090
может занять некоторое время, потому что
очень большой download-- вы собираетесь

50
00:03:02,090 --> 00:03:07,060
работать в В.М. SUDO обновления APT-GET.

51
00:03:07,060 --> 00:03:09,410
И что на самом деле происходит
обновить все программное обеспечение,

52
00:03:09,410 --> 00:03:12,670
пакеты на вашей виртуальной машине.

53
00:03:12,670 --> 00:03:20,130
>> После этого, вы собираетесь запустить
Судо APT-получить установку, libsdl2-2.0-0,

54
00:03:20,130 --> 00:03:27,960
libsdl2-DBG, libsdl2-DEV, а
дополнительно libsdl2-изображения 2.0-0,

55
00:03:27,960 --> 00:03:32,560
libsdl2-изображения DBG,
и libsdl2-изображения DEV.

56
00:03:32,560 --> 00:03:33,640
Так что это делает?

57
00:03:33,640 --> 00:03:38,440
Это всего лишь устанавливает отладки
информации, документации, заголовки,

58
00:03:38,440 --> 00:03:41,260
и бинарные файлы для двух библиотек.

59
00:03:41,260 --> 00:03:45,090
Регулярный старый, SDL 2.0,
и еще библиотека

60
00:03:45,090 --> 00:03:50,110
называется SDL изображения, которые
мы собираемся использовать

61
00:03:50,110 --> 00:03:54,560
загружать файлы изображений в нашей игре.

62
00:03:54,560 --> 00:03:57,860
>> Поэтому, как только у вас есть, что также
что, как раз когда он просит,

63
00:03:57,860 --> 00:04:01,100
Вы просто наберите да, нажмите Ввод
установить эти пакеты,

64
00:04:01,100 --> 00:04:04,430
а затем вы должны быть хорошо идти.

65
00:04:04,430 --> 00:04:14,800
Таким образом, чтобы получить код распределения, вы
can-- боже, это не обновляется.

66
00:04:14,800 --> 00:04:18,480
Если у вас есть account-- GitHub
если у вас есть аккаунт GitHub,

67
00:04:18,480 --> 00:04:24,450
Вы можете сделать это Git
клон команда репо

68
00:04:24,450 --> 00:04:30,490
и что будет скачать Git
РЕПО со всеми кода в нем,

69
00:04:30,490 --> 00:04:31,700
так что вы будете иметь код.

70
00:04:31,700 --> 00:04:36,470
>> Если вы не имеете GitHub
счет, то, что вы должны сделать, это ввести

71
00:04:36,470 --> 00:04:48,867
wgithttps: //github.com/tlively/sdl
seminar-- и здесь это different--

72
00:04:48,867 --> 00:04:49,700
/archive/master.zip.

73
00:04:49,700 --> 00:04:55,610

74
00:04:55,610 --> 00:04:59,220
Итак, еще раз, это точно такой же
Ссылка, за исключением того, что происходит, чтобы быть

75
00:04:59,220 --> 00:05:09,010
tlively / SDL_seminar / master.zip и
Вы используете wgit на скачивание этого.

76
00:05:09,010 --> 00:05:12,940
И тогда вы можете просто
распаковать этот архив

77
00:05:12,940 --> 00:05:14,900
и тогда вы будете иметь
весь исходный код.

78
00:05:14,900 --> 00:05:17,580
Так жаль, что так.

79
00:05:17,580 --> 00:05:23,880
А потом код также будет размещен на
веб-страницы в CS50 семинара в паре

80
00:05:23,880 --> 00:05:25,230
дней.

81
00:05:25,230 --> 00:05:26,590
>> Отлично.

82
00:05:26,590 --> 00:05:29,932
Так как мы начнем
писать нашу собственную игру?

83
00:05:29,932 --> 00:05:31,890
Ну, первое, что
мы собираемся хотите сделать

84
00:05:31,890 --> 00:05:34,740
это посмотреть на SDL документации.

85
00:05:34,740 --> 00:05:37,020
Так вот В.М..

86
00:05:37,020 --> 00:05:38,720
А вот веб-страница.

87
00:05:38,720 --> 00:05:40,340
Я вышел, чтобы жить libsdl.org.

88
00:05:40,340 --> 00:05:43,110

89
00:05:43,110 --> 00:05:48,140
То, что я собираюсь сделать здесь перейти
к боковой панели, под документации,

90
00:05:48,140 --> 00:05:51,040
и нажмите на вики.

91
00:05:51,040 --> 00:05:56,870
Это принесет мне в вики, что
имеет большинство документации для SDL.

92
00:05:56,870 --> 00:06:01,360
За на боковой панели здесь, мы
собирается нажмите API по категориям,

93
00:06:01,360 --> 00:06:04,300
потому что собирается дать
нам приятно категорична вид

94
00:06:04,300 --> 00:06:07,770
всего API для SDL.

95
00:06:07,770 --> 00:06:12,390
>> Так, например, у нас есть
основной инициализации

96
00:06:12,390 --> 00:06:18,380
и закрыли, все то
Административный материал для использования SDL,

97
00:06:18,380 --> 00:06:21,630
а то у нас в разделе для
отображения вещи на экране.

98
00:06:21,630 --> 00:06:23,000
Это видео.

99
00:06:23,000 --> 00:06:25,790
Входные события, это становится
ввести с клавиатуры,

100
00:06:25,790 --> 00:06:29,710
получать ввод от мыши, и
джойстик, если у вас есть даже.

101
00:06:29,710 --> 00:06:32,901
Там же обратной силой вещей
как игровые контроллеры, которые

102
00:06:32,901 --> 00:06:34,150
мы не собираемся говорить.

103
00:06:34,150 --> 00:06:35,630
А вот звук.

104
00:06:35,630 --> 00:06:38,940
А тут еще куча других
вещи, которые SDL может сделать для вас.

105
00:06:38,940 --> 00:06:43,830
>> Но сегодня мы собираемся сосредоточиться
на инициализации здесь,

106
00:06:43,830 --> 00:06:48,332
отображения изображений в видео
раздел, и обработку событий ввода.

107
00:06:48,332 --> 00:06:50,290
Так вот главные
разделы документации

108
00:06:50,290 --> 00:06:53,050
что вы должны беспокоиться о.

109
00:06:53,050 --> 00:06:57,170
Просто для удовольствия, если перейти
здесь и нажмите на API по имени,

110
00:06:57,170 --> 00:07:04,350
мы можем увидеть список всех
отдельная вещь в SDL библиотеке.

111
00:07:04,350 --> 00:07:11,330
Таким образом, все эти функции, перечисления,
структуры, сумасшедшее количество материала,

112
00:07:11,330 --> 00:07:12,820
Алфавитный порядок.

113
00:07:12,820 --> 00:07:14,580
Не И ясно, что до тех пор,
Вы знаете, что вы делаете,

114
00:07:14,580 --> 00:07:19,100
это не будет слишком полезным,
который является, почему мы делаем API по категориям.

115
00:07:19,100 --> 00:07:20,810
>> Итак, давайте начнем.

116
00:07:20,810 --> 00:07:25,680
Надеюсь, вы уже
загрузили код распределения.

117
00:07:25,680 --> 00:07:30,070
И так, что вы можете сделать, это, право
здесь, в CS50 прибора,

118
00:07:30,070 --> 00:07:31,150
просто откройте терминал.

119
00:07:31,150 --> 00:07:33,750

120
00:07:33,750 --> 00:07:34,440
Вот так.

121
00:07:34,440 --> 00:07:40,740
Так что я уже скачал
Код распределения с помощью .zip

122
00:07:40,740 --> 00:07:41,690
способ.

123
00:07:41,690 --> 00:07:43,140
И я расстегнул его.

124
00:07:43,140 --> 00:07:46,120
Так вот в SDL мастера семинара.

125
00:07:46,120 --> 00:07:49,750
Так что я собираюсь идти в этом каталоге.

126
00:07:49,750 --> 00:07:55,310
И то, что мы видим здесь
что у нас есть семь C файлы.

127
00:07:55,310 --> 00:07:58,070
И это будет код
мы собираемся быть глядя на сегодняшний день.

128
00:07:58,070 --> 00:08:00,040
У нас есть Makefile.

129
00:08:00,040 --> 00:08:06,950
И у нас есть каталог ресурсов,
который просто имеет изображение

130
00:08:06,950 --> 00:08:09,070
что вы будете видеть достаточно скоро.

131
00:08:09,070 --> 00:08:16,060
>> Так давайте откроем эти файлы
с помощью G-Edit редактора.

132
00:08:16,060 --> 00:08:22,000
Поэтому я хочу, чтобы открыть все файлы, которые
Начнем с привет и оканчиваются на .c.

133
00:08:22,000 --> 00:08:23,380
Вот так.

134
00:08:23,380 --> 00:08:28,180
Так что это крошечное окно, таким образом, мы
собираюсь попробовать сделать что больше.

135
00:08:28,180 --> 00:08:28,900
Нет, он ушел.

136
00:08:28,900 --> 00:08:32,836

137
00:08:32,836 --> 00:08:34,570
>> Отлично.

138
00:08:34,570 --> 00:08:37,959
Так вот самое первое
Файл мы собираемся смотреть.

139
00:08:37,959 --> 00:08:39,000
Это называется hello1_sdl.c.

140
00:08:39,000 --> 00:08:41,890

141
00:08:41,890 --> 00:08:47,980
И все это делает инициализацию SDL
Библиотека, так что мы можем начать использовать его.

142
00:08:47,980 --> 00:08:51,550
Как бы Вы знаете, чтобы прийти
с этим кодом сами?

143
00:08:51,550 --> 00:08:53,850
Ну, если мы посмотрим более
в документации

144
00:08:53,850 --> 00:08:58,040
и мы идем в инициализации
и закрыли раздел,

145
00:08:58,040 --> 00:09:02,230
он собирается рассказать нам
о том, как инициализировать SDL.

146
00:09:02,230 --> 00:09:06,630
Так, безусловно, читать это в другой раз.

147
00:09:06,630 --> 00:09:09,230
Это происходит, чтобы сказать вам все
о том, что здесь происходит.

148
00:09:09,230 --> 00:09:14,360
Но главное затруднение в том, что
мы должны вызвать эту функцию SDL В Этом

149
00:09:14,360 --> 00:09:18,910
и передать его, какие вещи
мы хотим, чтобы библиотека для инициализации.

150
00:09:18,910 --> 00:09:23,620
Таким образом, в нашем случае, мы просто
инициализировать видео сейчас,

151
00:09:23,620 --> 00:09:26,690
так что мы можем начать показ изображений.

152
00:09:26,690 --> 00:09:32,370
>> Здесь, вы можете увидеть, если
кликаем на SDL в нем, мы

153
00:09:32,370 --> 00:09:36,160
может получить еще больше информации,
в том числе возвращаемого значения.

154
00:09:36,160 --> 00:09:39,050
Таким образом, мы видим, что это
returnes нулю на успех.

155
00:09:39,050 --> 00:09:43,320
Таким образом, в нашем коде, мы собираемся
увидеть, если она не вернется к нулю,

156
00:09:43,320 --> 00:09:47,020
и если он не возвращает
нулю, так что это не было успешным,

157
00:09:47,020 --> 00:09:50,650
тогда мы идем к печати просто
ошибка при использовании этого другую функцию,

158
00:09:50,650 --> 00:09:56,260
SDL ошибок Get, который возвращает строку
описывая ошибка, возникавшая.

159
00:09:56,260 --> 00:09:58,510
Мы собираемся, чтобы распечатать что
ошибки, а затем мы просто

160
00:09:58,510 --> 00:10:02,270
собирается выйти из программы
с кодом ошибки.

161
00:10:02,270 --> 00:10:06,470
>> Тогда другое дело, что мы должны
сделать это до выхода из программы,

162
00:10:06,470 --> 00:10:10,830
если мы успешно инициализирован SDL,
нам просто нужно назвать его SDL выйти.

163
00:10:10,830 --> 00:10:15,750
И, что собирается обращаться очистки
все внутренние ресурсы SDL для нас.

164
00:10:15,750 --> 00:10:21,240
Таким образом, документация there-- снова,
здесь мы находимся в инициализации

165
00:10:21,240 --> 00:10:23,640
и закрыли раздел
документации.

166
00:10:23,640 --> 00:10:26,680
Вы можете просто нажмите на
Функция здесь, SDL бросить,

167
00:10:26,680 --> 00:10:28,700
и вы можете прочитать все о том, что, как хорошо.

168
00:10:28,700 --> 00:10:31,400
И многие из этих функций
страницы документации

169
00:10:31,400 --> 00:10:35,630
есть пример кода, так что это
очень хороший ресурс.

170
00:10:35,630 --> 00:10:39,610
Определенно потратить некоторое время
читать части этой вики

171
00:10:39,610 --> 00:10:42,520
если вы собираетесь сделать
это для проекта.

172
00:10:42,520 --> 00:10:43,760
>> Отлично.

173
00:10:43,760 --> 00:10:46,590
Так вот вся наша программа.

174
00:10:46,590 --> 00:10:53,935
Что мы можем сделать сейчас, я is--
собирается открыть Makefile здесь,

175
00:10:53,935 --> 00:10:56,150
так что я собираюсь взять
посмотреть на, как это работает.

176
00:10:56,150 --> 00:10:59,500
И это очень простой Makefile,
похоже на то, что вы видели раньше.

177
00:10:59,500 --> 00:11:04,010
Одним из основных отличий
является то, что здесь, в этом

178
00:11:04,010 --> 00:11:07,870
будет вставить результат бега
Эта команда, вы уже

179
00:11:07,870 --> 00:11:10,850
установлен, если вы установили SDL.

180
00:11:10,850 --> 00:11:13,230
И это команда
который будет генерировать

181
00:11:13,230 --> 00:11:16,710
некоторые дополнительные флаги для компилятора.

182
00:11:16,710 --> 00:11:22,050
>> Кроме того, мы даем его
все обычные команды, а также

183
00:11:22,050 --> 00:11:23,430
эти две команды.

184
00:11:23,430 --> 00:11:30,270
Так что -lsdl2-изображения ручки
связывая в библиотеке SDL изображения.

185
00:11:30,270 --> 00:11:36,200
И на самом деле -lm обрабатывает связывание
в стандартной математической библиотеки C.

186
00:11:36,200 --> 00:11:40,630
Таким образом, мы не понадобится
тех, для всех наших файлов на Си,

187
00:11:40,630 --> 00:11:43,900
но мы просто положить их в так что мы можем
использовать ту же Makefile для всего

188
00:11:43,900 --> 00:11:44,816
без изменений.

189
00:11:44,816 --> 00:11:46,970

190
00:11:46,970 --> 00:11:50,080
>> Сюда в источниках,
это где вы бы

191
00:11:50,080 --> 00:11:53,680
поместить файлы, которые вы собираетесь
компилировать для вашего проекта.

192
00:11:53,680 --> 00:11:57,570
Но так как каждый из моей C
файлы сюда имеет основную функцию,

193
00:11:57,570 --> 00:12:00,000
это будет запутаться
если положить их в.

194
00:12:00,000 --> 00:12:06,930
Так что я собираюсь просто сказать,
сейчас, hello1_sdl.c,

195
00:12:06,930 --> 00:12:11,150
который является одним мы просто смотрели.

196
00:12:11,150 --> 00:12:18,740
Так что, если я возвращаюсь в течение
здесь, я могу действительно делают.

197
00:12:18,740 --> 00:12:22,160
И что он сделал это просто
составлен, что первый файл.

198
00:12:22,160 --> 00:12:28,780
И тогда мы можем ввести ./game, потому что
это исполняемый файл он произвел.

199
00:12:28,780 --> 00:12:31,660
И все это сделал для печати
инициализация успешно.

200
00:12:31,660 --> 00:12:33,300
Таким образом, мы сделали что-то правильное.

201
00:12:33,300 --> 00:12:36,200
Но это было скучно,
потому что мы не видим окно,

202
00:12:36,200 --> 00:12:37,900
ничего не двигалось вокруг.

203
00:12:37,900 --> 00:12:41,030
>> Так здорово, мы получили SDL инициализируются.

204
00:12:41,030 --> 00:12:43,520
Теперь, давайте перейдем к чему-то
немного более интересным.

205
00:12:43,520 --> 00:12:54,700
Так вот у нас есть hello2_window.c, и
это будет немного больше

206
00:12:54,700 --> 00:13:00,010
комплекс С программа,
инициализирует SDL, как и раньше,

207
00:13:00,010 --> 00:13:04,250
только теперь мы также собираемся
для инициализации SDL таймер.

208
00:13:04,250 --> 00:13:07,720
И это будет, чтобы сообщить нам
доступ к внутренней таймер

209
00:13:07,720 --> 00:13:10,550
и использовать функции, относящиеся к времени.

210
00:13:10,550 --> 00:13:11,920
>> А потом посмотрим сюда.

211
00:13:11,920 --> 00:13:16,840
То, что мы делаем, мы должны этот указатель
к SDL окно структуры, которая

212
00:13:16,840 --> 00:13:21,160
будет создаваться этот призыв
функции, SDL создать окно.

213
00:13:21,160 --> 00:13:25,380
Теперь, это занимает много аргументов,
так что давайте смотреть на документацию.

214
00:13:25,380 --> 00:13:27,930
Итак, еще раз, я собираюсь
API по категориям, я

215
00:13:27,930 --> 00:13:33,820
снижается в видео здесь, и первый
раздел, показывая управление окнами.

216
00:13:33,820 --> 00:13:36,470
Таким образом, это секция имеет
тонна вещей в нем,

217
00:13:36,470 --> 00:13:39,970
но если вы смотрите через
эти функции, вы будете

218
00:13:39,970 --> 00:13:43,620
видеть, что вероятно, один мы
нужен, называется SDL создать окно,

219
00:13:43,620 --> 00:13:46,600
который, случается, на самом верху.

220
00:13:46,600 --> 00:13:49,080
>> И поэтому это
документация для этой функции.

221
00:13:49,080 --> 00:13:53,710
Окно будет иметь заголовок,
Х и Y позиции на экране,

222
00:13:53,710 --> 00:13:56,960
это будет иметь ширину, высоту,
а затем он собирается принять некоторые флаги.

223
00:13:56,960 --> 00:14:01,220
Теперь мы на самом деле не волнует
любой из этих флагов сейчас

224
00:14:01,220 --> 00:14:04,560
но если вы хотите сделать что-то
как сделать окно во весь экран,

225
00:14:04,560 --> 00:14:07,920
Вы могли бы взглянуть на это.

226
00:14:07,920 --> 00:14:13,190
В настоящее время, мы только собираемся
использовать эти специальные значения,

227
00:14:13,190 --> 00:14:18,775
SDL окно плюс центру
для х и у в порядке

228
00:14:18,775 --> 00:14:21,800
просто создать окно
в центре нашего экрана.

229
00:14:21,800 --> 00:14:24,370
>> Так вот, что это делает.

230
00:14:24,370 --> 00:14:27,960
А если окно случается
NULL, означая, что это ошибка,

231
00:14:27,960 --> 00:14:32,570
Затем мы снова собираемся просто
распечатать, используя SDL ошибку ошибку получите.

232
00:14:32,570 --> 00:14:36,570
А потом, потому что мы инициализации
SDL, нам нужно, чтобы закрыть его.

233
00:14:36,570 --> 00:14:40,900
Так мы называем SDL, прежде чем бросить
Возвращая одну для основной.

234
00:14:40,900 --> 00:14:42,905
>> Итак, мы имеем окно открыть, надеюсь.

235
00:14:42,905 --> 00:14:44,613
И что мы собираемся
сделать, мы собираемся

236
00:14:44,613 --> 00:14:50,340
позвонить SDL для 5000 миллисекунд,
что то же самое, как пять секунд.

237
00:14:50,340 --> 00:14:55,640
И когда мы сделали с этим,
он собирается уничтожить окно,

238
00:14:55,640 --> 00:14:59,470
убирать библиотека SDL,
и выйти из программы.

239
00:14:59,470 --> 00:15:05,240
Так что давайте идти вперед и дать, что выстрел.

240
00:15:05,240 --> 00:15:08,660
>> Так что теперь вместо изменения
Makefile, каждый раз,

241
00:15:08,660 --> 00:15:12,180
Я могу просто сделать, и
Затем в командной строке,

242
00:15:12,180 --> 00:15:16,090
говорят источники равна, а затем
файл мы компиляции.

243
00:15:16,090 --> 00:15:17,090
Так что это hello2_window.c.

244
00:15:17,090 --> 00:15:21,390

245
00:15:21,390 --> 00:15:21,890
Фантастика.

246
00:15:21,890 --> 00:15:22,970
Нет erros.

247
00:15:22,970 --> 00:15:26,085
Теперь, если мы запустим наш исполняемый файл,
мы видим это окно.

248
00:15:26,085 --> 00:15:27,960
Теперь есть несколько
Проблемы с окном.

249
00:15:27,960 --> 00:15:32,820
Мы можем переместить его вокруг, но она имеет
На этом фоне нежелательной внутри него.

250
00:15:32,820 --> 00:15:34,660
Таким образом, мы не тянет
что-нибудь, и так это

251
00:15:34,660 --> 00:15:38,210
только полный мусор, который
это довольно много, что мы ожидаем.

252
00:15:38,210 --> 00:15:41,010
>> Кроме того, мы не можем закрыть окно.

253
00:15:41,010 --> 00:15:44,780
Я нажатии этой X в
угол и ничего, что происходит.

254
00:15:44,780 --> 00:15:47,840
Таким образом, мы увидим, как исправить
что в немного.

255
00:15:47,840 --> 00:15:51,750
Так что давайте исправить часть, где
Окно полна мусора в первую очередь.

256
00:15:51,750 --> 00:16:00,850
Так что, если мы идем к hello3_image.c, то, что
мы видим в том, что мы добавили несколько

257
00:16:00,850 --> 00:16:03,360
больше вещей здесь.

258
00:16:03,360 --> 00:16:08,740
Мы добавили этот новый заголовок
подать, чтобы получить функции таймера.

259
00:16:08,740 --> 00:16:11,490
Я думаю, что мы сделали это в последний
Один из них, тоже, и я не упоминать.

260
00:16:11,490 --> 00:16:13,550
Но теперь, потому что мы
работы с изображениями,

261
00:16:13,550 --> 00:16:18,720
мы должны включать SDL
Файл заголовка изображения, а также.

262
00:16:18,720 --> 00:16:22,087
Так что это то же самое,
прежде, инициализация SDL здесь,

263
00:16:22,087 --> 00:16:23,420
То же самое дело с созданием окна.

264
00:16:23,420 --> 00:16:25,380
Мы видели, что до сих пор.

265
00:16:25,380 --> 00:16:29,870
>> Теперь нам нужно создать что-то под названием
рендерер, который вроде идет вместе

266
00:16:29,870 --> 00:16:30,800
с окном.

267
00:16:30,800 --> 00:16:33,860
Но это своего рода
абстрактный объект, что это

268
00:16:33,860 --> 00:16:37,370
отвечающий делать все эти
рисунок операций к окну.

269
00:16:37,370 --> 00:16:41,580
И это на самом деле соответствует
на программы, загруженной

270
00:16:41,580 --> 00:16:47,880
в графическом оборудовании в вашей
компьютер или телефон, или что угодно.

271
00:16:47,880 --> 00:16:51,005
Таким образом, флаги, которые мы хотим передать it--
и вы можете смотреть на документацию

272
00:16:51,005 --> 00:16:56,160
чтобы получить более подробную информацию here-- собираетесь
чтобы быть SDL вынести ускоряется, что

273
00:16:56,160 --> 00:16:58,550
означает, что он будет
с помощью графического оборудования

274
00:16:58,550 --> 00:17:01,490
и не только эмулировать в программном обеспечении.

275
00:17:01,490 --> 00:17:07,390
>> И мы собираемся использовать
SDL рендеринга PRESENTVSYNC.

276
00:17:07,390 --> 00:17:12,280
VSYNC это вещь, которая просто делает
Ваши графики выглядят лучше и предотвращает

277
00:17:12,280 --> 00:17:14,970
это то, что называется экраном
террор, где половина

278
00:17:14,970 --> 00:17:17,720
одного кадра и половина следующего
рамка втянуться в то же время

279
00:17:17,720 --> 00:17:20,056
и это выглядит ужасно.

280
00:17:20,056 --> 00:17:23,130
Но, опять же, вы можете идти читать
о том, что по своему усмотрению.

281
00:17:23,130 --> 00:17:24,319
>> Итак, мы имеем некоторые флаги здесь.

282
00:17:24,319 --> 00:17:27,810
И так мы только собираемся называть
эта функция SDL создать визуализации.

283
00:17:27,810 --> 00:17:31,340
Мы собираемся дать ему окно
связать с этой визуализации.

284
00:17:31,340 --> 00:17:34,520
Отрицательный одним означает, что мы не волнует, что
Графический драйвер мы собираемся использовать.

285
00:17:34,520 --> 00:17:36,603
Так что надо очень много
всегда отрицательный,

286
00:17:36,603 --> 00:17:39,010
если вы не знаете о графических драйверов.

287
00:17:39,010 --> 00:17:41,650
И тогда мы только собираемся
передать ей наши флаги.

288
00:17:41,650 --> 00:17:47,240
Так что, если возвращается NULL, то мы
в печать ошибку, как обычно,

289
00:17:47,240 --> 00:17:49,550
но тогда мы также собираемся
уничтожить окно

290
00:17:49,550 --> 00:17:54,970
убирать эти ресурсы, прежде чем
называя SDL бросить и вернуться.

291
00:17:54,970 --> 00:17:58,110
>> Теперь, интересная часть здесь
то, где мы загружаем наш имидж

292
00:17:58,110 --> 00:18:00,870
Используя эту функцию IMG_load.

293
00:18:00,870 --> 00:18:04,050
Это единственная функция мы собираемся
использовать из библиотеки SDL изображения.

294
00:18:04,050 --> 00:18:05,480
Это единственный, кто нам нужен.

295
00:18:05,480 --> 00:18:12,950
Это функция, которая принимает строку
это путь любого ресурса изображения.

296
00:18:12,950 --> 00:18:18,024
И это может быть .png, А GIF,
растровые, любой из этих вещей.

297
00:18:18,024 --> 00:18:19,690
И вот почему эта функция так хорошо.

298
00:18:19,690 --> 00:18:22,560
Он может обрабатывать почти любой формат.

299
00:18:22,560 --> 00:18:27,240
Грузы его в память и сохраняет его
как вещь называется SDL поверхность.

300
00:18:27,240 --> 00:18:34,660
>> Теперь SDL поверхность лишь структура
которая представляет данные изображения в памяти.

301
00:18:34,660 --> 00:18:38,054
Таким образом, вы можете прочитать больше о
что в документации два.

302
00:18:38,054 --> 00:18:40,720
И если это ошибки, то мы
собираюсь сделать все это где

303
00:18:40,720 --> 00:18:44,480
мы печатаем ошибку, закрыть
ресурсы, а затем выйти из программы.

304
00:18:44,480 --> 00:18:48,970
Теперь самое интересное, до
мы можем сделать этот образ к окну,

305
00:18:48,970 --> 00:18:51,390
мы должны на самом деле сделать это текстура.

306
00:18:51,390 --> 00:18:54,460
Теперь текстура соответствует
к данным изображения, загруженных

307
00:18:54,460 --> 00:18:57,820
в память аппаратной графической из отдела.

308
00:18:57,820 --> 00:19:00,720
>> Таким образом, поверхность в основной
памяти, регулярное памяти

309
00:19:00,720 --> 00:19:05,550
что мы использовали все семестр,
и текстура в этой отдельной видеопамяти

310
00:19:05,550 --> 00:19:09,410
памяти, элементы управления графической карты.

311
00:19:09,410 --> 00:19:13,170
Так мы называем эту функцию
SDL_CreateTextureFromSurface.

312
00:19:13,170 --> 00:19:17,104
Мы даем ему нашу визуализации и наш поверхность.

313
00:19:17,104 --> 00:19:19,020
И тогда мы на самом деле
сделано с поверхностью,

314
00:19:19,020 --> 00:19:20,311
так мы только собираемся, чтобы освободить его.

315
00:19:20,311 --> 00:19:22,210
Мы не нужен.

316
00:19:22,210 --> 00:19:26,650
А потом, так что если этот призыв
ошибками и вернулся пустым,

317
00:19:26,650 --> 00:19:29,630
то мы собираемся сделать весь
Ошибка отчетности самое.

318
00:19:29,630 --> 00:19:30,920
>> Отлично.

319
00:19:30,920 --> 00:19:34,810
Здесь мы получаем в некоторые
фактические функции рендеринга.

320
00:19:34,810 --> 00:19:37,730
Так называя SDL_RenderClear
и передачи его

321
00:19:37,730 --> 00:19:42,550
рендер, связанные с нашим окном
просто делает окно темнеет.

322
00:19:42,550 --> 00:19:47,650
Так он снимает, что мусор, который мы видели в
наше окно, прежде чем она и делает черный.

323
00:19:47,650 --> 00:19:50,750
А потом мы собираемся
позвонить SDL_RenderCopy,

324
00:19:50,750 --> 00:19:53,010
дать ему наш визуализации, нашу текстуру.

325
00:19:53,010 --> 00:19:55,800
И мы будем говорить о том, что
эти поля находятся в немного.

326
00:19:55,800 --> 00:19:57,830
Но что происходит, чтобы
принять данные текстуры

327
00:19:57,830 --> 00:20:03,100
и скопировать его на наш
Окно для отрисовки изображения.

328
00:20:03,100 --> 00:20:07,020
Так после того как мы сделали эту копию
данных на нашем окне,

329
00:20:07,020 --> 00:20:11,180
мы должны сделать это дополнительная функция
называется SDL_RenderPresent.

330
00:20:11,180 --> 00:20:15,360
>> И это интересно
потому что это становится

331
00:20:15,360 --> 00:20:18,770
в теме под названием двойной буферизации.

332
00:20:18,770 --> 00:20:24,380
Так двойной буферизации является метод, который
делает ваши графики выглядят намного лучше.

333
00:20:24,380 --> 00:20:28,240
Опять же, это предотвращает разрыв экрана
Я говорил раньше, где

334
00:20:28,240 --> 00:20:29,590
у вас есть два буфера.

335
00:20:29,590 --> 00:20:32,260
Там это снова буфера в
память и передний буфер.

336
00:20:32,260 --> 00:20:36,410
Передняя буфер буквально
что на экране в данный момент.

337
00:20:36,410 --> 00:20:42,070
Таким образом, мы делаем все это нарисовать вариации,
как SDL оказать копию или SDL_RenderClear

338
00:20:42,070 --> 00:20:43,080
во вторичный буфер.

339
00:20:43,080 --> 00:20:44,800
Так они изменяют вещи
В заднего буфера.

340
00:20:44,800 --> 00:20:48,970
Здесь мы могли бы рисовать этот
зеленый квадрат, чтобы буфера.

341
00:20:48,970 --> 00:20:52,300
>> Итак, когда мы сделали делать
наши делают операции, которые

342
00:20:52,300 --> 00:20:55,700
может занять очень долго
Время, что мы собираемся сделать

343
00:20:55,700 --> 00:20:57,860
это переключить буферы.

344
00:20:57,860 --> 00:21:00,720
Так что буквально берет
передний буфер и обратно буфер

345
00:21:00,720 --> 00:21:02,990
и переключает их, так
что, мгновенно,

346
00:21:02,990 --> 00:21:06,630
за одну операцию вместо
может быть, сотни или тысячи,

347
00:21:06,630 --> 00:21:10,910
все наши вновь оказывается
объекты на экране.

348
00:21:10,910 --> 00:21:13,160
И это мешает вещи
как обновлять экран

349
00:21:13,160 --> 00:21:16,710
когда мы только половина обращается
наших объектов в кадре.

350
00:21:16,710 --> 00:21:21,280
Так вот почему мы должны вызвать
SDL_RenderPresent, а также

351
00:21:21,280 --> 00:21:23,320
а SDL_RenderCopy.

352
00:21:23,320 --> 00:21:25,749
>> Опять же, мы только собираемся
ждать в течение пяти секунд.

353
00:21:25,749 --> 00:21:27,540
Тогда мы идем к
очистить наши ресурсы.

354
00:21:27,540 --> 00:21:29,540
У нас есть довольно несколько более в этот раз.

355
00:21:29,540 --> 00:21:31,750
И тогда мы только собираемся
для выхода из программы.

356
00:21:31,750 --> 00:21:35,350
Так давайте сделаем это.

357
00:21:35,350 --> 00:21:41,880
Я собираюсь ввести марку, а затем источники
равна hello-- это теперь 3image.c.

358
00:21:41,880 --> 00:21:49,632

359
00:21:49,632 --> 00:21:52,240
Ладно, не составлен без ошибок.

360
00:21:52,240 --> 00:21:57,210
И вы можете посмотреть здесь Я теперь
вытягивается мое изображение, Привет, CS50!

361
00:21:57,210 --> 00:22:00,560
в нашем окне, которое
исчезает через пять секунд.

362
00:22:00,560 --> 00:22:02,090
>> Теперь, это все еще есть проблемы, не так ли?

363
00:22:02,090 --> 00:22:05,750
Это не хорошее приложение,
потому что, когда я пытаюсь закрыть окно,

364
00:22:05,750 --> 00:22:06,500
Ничего не произошло.

365
00:22:06,500 --> 00:22:09,540
Это х по-прежнему не отвечает.

366
00:22:09,540 --> 00:22:17,420
Итак, давайте взглянем на
следующий файл, hello4animation.

367
00:22:17,420 --> 00:22:21,850
Так что это файл
что собирается ввести

368
00:22:21,850 --> 00:22:25,124
перемещение и движение к нашему изображению.

369
00:22:25,124 --> 00:22:27,040
Так что мы собираемся сделать
То же самое, как и прежде,

370
00:22:27,040 --> 00:22:30,190
инициировать SDL, создать
окна, создать визуализации,

371
00:22:30,190 --> 00:22:33,030
загрузить изображение в
памяти, создать текстуру.

372
00:22:33,030 --> 00:22:35,090
Мы видели все это раньше.

373
00:22:35,090 --> 00:22:36,770
Теперь, вот это новое.

374
00:22:36,770 --> 00:22:42,305
Мы собираемся, чтобы иметь структуру, называемую
SDL прямоугольник, который является просто прямоугольник.

375
00:22:42,305 --> 00:22:49,950
Если мы идем сюда, мы можем
сделать поиск для SDL прямоугольника,

376
00:22:49,950 --> 00:22:54,040
и вы можете видеть, что это
Очень простая структура.

377
00:22:54,040 --> 00:22:56,760
Он имеет х, а у для
положение, и

378
00:22:56,760 --> 00:23:02,080
имеет ширину и высоту для
размер прямоугольника.

379
00:23:02,080 --> 00:23:07,785
>> Итак, что мы собираемся сделать, это мы
будет определять этот SDL прямоугольника адресата,

380
00:23:07,785 --> 00:23:09,480
для назначения.

381
00:23:09,480 --> 00:23:14,130
И это место,
на экране, где

382
00:23:14,130 --> 00:23:16,005
мы собираемся быть рисунок
наш образ, прямо так

383
00:23:16,005 --> 00:23:17,880
если мы собираемся быть
перемещения изображения вокруг,

384
00:23:17,880 --> 00:23:20,300
то назначения, где
мы собираемся привлечь изображение

385
00:23:20,300 --> 00:23:22,620
должны быть в движении.

386
00:23:22,620 --> 00:23:24,910
Итак, мы собираемся назвать это
Функция SDL_QueryTexture.

387
00:23:24,910 --> 00:23:27,550

388
00:23:27,550 --> 00:23:33,500
И заметьте, я передаю адрес
из dest.w, что ширина,

389
00:23:33,500 --> 00:23:36,950
и dest.h, что высота.

390
00:23:36,950 --> 00:23:40,425
И так будет SDL_QueryTexture
хранить в этих областях ширина

391
00:23:40,425 --> 00:23:41,675
а высота нашей текстуры.

392
00:23:41,675 --> 00:23:44,680

393
00:23:44,680 --> 00:23:47,030
>> И тогда то, что я собираюсь
сделать, я собираюсь

394
00:23:47,030 --> 00:23:55,580
установить dest.x быть окно
ширина минус dest.w, что

395
00:23:55,580 --> 00:23:59,000
ширина спрайта, делится на 2.

396
00:23:59,000 --> 00:24:03,860
И это будет настроить его так,
что образ идеально по центру

397
00:24:03,860 --> 00:24:06,780
в нашем окне, все в порядке?

398
00:24:06,780 --> 00:24:08,652
Так что теперь у меня есть позиция у.

399
00:24:08,652 --> 00:24:10,360
И это будет
быть переменной, которая

400
00:24:10,360 --> 00:24:16,390
меняется, потому что мы собираемся, чтобы быть
перемещения изображения в направлении у.

401
00:24:16,390 --> 00:24:19,050
И теперь у нас есть что-то
называется цикл анимации.

402
00:24:19,050 --> 00:24:21,180
>> Так как же анимация работает?

403
00:24:21,180 --> 00:24:27,630
Ну, человеческий глаз может обнаружить 12 различных
изображения в каждую секунду, ладно?

404
00:24:27,630 --> 00:24:33,060
Так что, если вы мигать 12 изображений карт на меня
в секунду, я видел каждый из этих образов

405
00:24:33,060 --> 00:24:35,950
а своим собственным отдельного изображения.

406
00:24:35,950 --> 00:24:39,690
Теперь, если вы мигать более
изображения у меня в секунду,

407
00:24:39,690 --> 00:24:42,140
то мой глаз начнет
чтобы размыть их вместе

408
00:24:42,140 --> 00:24:46,920
и я бы воспринимать его как движение,
вместо одного отдельного изображения.

409
00:24:46,920 --> 00:24:51,930
Так, например, кино и телевидения,
они мигают изображения у вас 24 раза

410
00:24:51,930 --> 00:24:52,570
Второй.

411
00:24:52,570 --> 00:24:55,110
Так вот 24 кадров в секунду.

412
00:24:55,110 --> 00:25:00,136
Экраны компьютера, с другой стороны,
часто при 60 кадрах в секунду.

413
00:25:00,136 --> 00:25:01,260
Это их скорость обновления.

414
00:25:01,260 --> 00:25:04,650
Вот как часто они обновить
изображение на экране.

415
00:25:04,650 --> 00:25:08,960
Таким образом, наша цель будет 60
кадров в секунду для наших игр.

416
00:25:08,960 --> 00:25:11,770

417
00:25:11,770 --> 00:25:13,710
>> Итак, давайте посмотрим, что в коде.

418
00:25:13,710 --> 00:25:19,064
Таким образом, для каждого кадра, мы в первую очередь
собирается очистить окно.

419
00:25:19,064 --> 00:25:20,230
Это общая картина.

420
00:25:20,230 --> 00:25:22,450
Вы всегда очистить
Окно каждый кадр, а затем

421
00:25:22,450 --> 00:25:25,210
делать все на чертеже
операции, а затем в конце концов,

422
00:25:25,210 --> 00:25:29,610
у RenderPresent, чтобы показать
все в кадре.

423
00:25:29,610 --> 00:25:33,910
И тогда вы будете
есть ожидание в конце

424
00:25:33,910 --> 00:25:36,340
не ждать до следующего
рама должна начаться.

425
00:25:36,340 --> 00:25:38,650
>> Так что, если я делаю много
Комплекс вычисление здесь

426
00:25:38,650 --> 00:25:43,100
что потребовалось более 16 миллисекунд,
было бы невозможно для меня

427
00:25:43,100 --> 00:25:46,890
чтобы получить, что частота кадров 60, что
Я хотел, потому что каждый кадр

428
00:25:46,890 --> 00:25:48,750
слишком долго, чтобы вычислить.

429
00:25:48,750 --> 00:25:52,340
Кроме того, мы действительно делаем
Сортировать ничтожного количества работы

430
00:25:52,340 --> 00:25:54,820
здесь, потому что есть только
Единственное, что мы рисуем.

431
00:25:54,820 --> 00:25:59,390
Так что я просто подождать 1/60
во-вторых, что длина

432
00:25:59,390 --> 00:26:01,520
рамы между кадрами.

433
00:26:01,520 --> 00:26:05,610
Так что я вроде притворяясь делать
вся моя работа занимает нулевое время.

434
00:26:05,610 --> 00:26:09,050
Но в реальной игре,
вы должны вычесть

435
00:26:09,050 --> 00:26:13,760
количество времени, которое потребовалось, чтобы сделать
вся эта работа с Вашего времени отдыха.

436
00:26:13,760 --> 00:26:16,970
>> Так или иначе, что я
на самом деле делает в этом цикле?

437
00:26:16,970 --> 00:26:19,070
Очистить окно.

438
00:26:19,070 --> 00:26:27,470
Я установил dest.y, который является INT, чтобы
моя фактическая позиция у брошен в междунар.

439
00:26:27,470 --> 00:26:32,070
Теперь я хочу, плавать разрешение
для моей позиции у в моей игре,

440
00:26:32,070 --> 00:26:34,150
но тогда на самом деле
нарисовать его на экране,

441
00:26:34,150 --> 00:26:39,070
он должен Интс, потому что это в единицах
пикселей, так это то, что приведение в.

442
00:26:39,070 --> 00:26:41,745
Я собираюсь нарисовать изображение.

443
00:26:41,745 --> 00:26:45,180
Так что это исходный прямоугольник.

444
00:26:45,180 --> 00:26:47,060
И это прямоугольник назначения.

445
00:26:47,060 --> 00:26:50,310
Так я прошел нуль для
источник прямоугольник

446
00:26:50,310 --> 00:26:53,426
сказать, что я хочу обратить всю свою текстуру.

447
00:26:53,426 --> 00:26:55,300
Но если у вас много
текстуры в вашей игре

448
00:26:55,300 --> 00:26:59,120
и все они в один большой карты текстуры
который был загружен в SDL в только один

449
00:26:59,120 --> 00:27:02,850
текстуры, вы могли бы
использовать исходный прямоугольник

450
00:27:02,850 --> 00:27:06,750
выбрать один из небольших текстур,
один из небольших спрайтов,

451
00:27:06,750 --> 00:27:09,450
из этого большой карте текстуры.

452
00:27:09,450 --> 00:27:14,740
>> Итак, еще раз, я передаю мой рендер, мой
текстура, и в настоящее время назначения.

453
00:27:14,740 --> 00:27:18,320
Это будет где в
Окно это будет обращено.

454
00:27:18,320 --> 00:27:21,390
А потом, потому что я рисую
то, мне нужно движение,

455
00:27:21,390 --> 00:27:25,150
Я собираюсь быть обновлению
Положение спрайт в каждом кадре.

456
00:27:25,150 --> 00:27:30,190
Так что у меня это постоянное названием свиток
скорости в блоки пикселей в секунду.

457
00:27:30,190 --> 00:27:34,320
Теперь, каждый раз, когда мы делаем движение,
кадр только 1/60 секунды.

458
00:27:34,320 --> 00:27:36,740
Так что я собираюсь разделить, что на 60.

459
00:27:36,740 --> 00:27:42,350
А потом, давайте посмотрим, я
вычитания, что с позиции у.

460
00:27:42,350 --> 00:27:44,470
Почему я вычитания?

461
00:27:44,470 --> 00:27:46,169
Мы вернемся к этому в секунду.

462
00:27:46,169 --> 00:27:48,460
Тогда я очистить свои ресурсы
и программа закончится.

463
00:27:48,460 --> 00:27:49,830
>> Так давайте сделаем это.

464
00:27:49,830 --> 00:27:52,450

465
00:27:52,450 --> 00:28:03,570
Так что давайте идти в макияж SRCS = hello4
animation.c, все в порядке?

466
00:28:03,570 --> 00:28:05,720
Игра.

467
00:28:05,720 --> 00:28:06,770
Там вы идете.

468
00:28:06,770 --> 00:28:12,690
Так он у меня прокрутки вверх по
окно, которое является довольно опрятно.

469
00:28:12,690 --> 00:28:17,110
Но держитесь, я был вычитания
от положения у каждый раз.

470
00:28:17,110 --> 00:28:18,910
Что там происходит?

471
00:28:18,910 --> 00:28:24,010
Ну, получается, что в SDL, и
В самом деле, в большинстве компьютерной графики,

472
00:28:24,010 --> 00:28:28,890
происхождение для системы координат
является верхней левой части окна.

473
00:28:28,890 --> 00:28:34,960
>> Таким образом, положительное направление идет х
по вашему окне справа.

474
00:28:34,960 --> 00:28:38,110
И положительный у направление
на самом деле идет вниз.

475
00:28:38,110 --> 00:28:40,470
Итак, еще раз, в происхождении в
верхний левый окна,

476
00:28:40,470 --> 00:28:46,190
положительное направление у вниз,
и положительный х вправо.

477
00:28:46,190 --> 00:28:48,770
Поэтому, когда я вычесть из
позиция у, это

478
00:28:48,770 --> 00:28:52,640
собирается сделать это перейти на негативе
у направление, которое составляет окне.

479
00:28:52,640 --> 00:28:55,500
Так вот то, что там происходит.

480
00:28:55,500 --> 00:28:56,510
Круто.

481
00:28:56,510 --> 00:28:59,240
>> Давайте посмотрим на следующий файл.

482
00:28:59,240 --> 00:29:05,700
Вот часть из
показать, где мы, наконец,

483
00:29:05,700 --> 00:29:08,920
получить эту X в углу окна
что, как предполагается, чтобы закрыть окно

484
00:29:08,920 --> 00:29:10,660
работать.

485
00:29:10,660 --> 00:29:12,800
Так, что происходит?

486
00:29:12,800 --> 00:29:17,520
Мы инициализируем SDL, создать окно,
создать визуализации, загрузите изображение,

487
00:29:17,520 --> 00:29:19,770
создать текстуру
как мы видели раньше.

488
00:29:19,770 --> 00:29:26,850
У нас же прямоугольник назначения
как и прежде, тот же вызов, чтобы запросить текстуру.

489
00:29:26,850 --> 00:29:29,780
Но в этот раз, мы тогда
разделим ширину

490
00:29:29,780 --> 00:29:33,110
и высота нашего назначения по 4.

491
00:29:33,110 --> 00:29:36,430
Это имеет только эффект
масштабирования наш образ вниз, когда

492
00:29:36,430 --> 00:29:39,884
мы показываем его в окне на четыре.

493
00:29:39,884 --> 00:29:40,800
Так что это довольно опрятно.

494
00:29:40,800 --> 00:29:42,770
Мы можем просто масштабировать просто так.

495
00:29:42,770 --> 00:29:45,970
Мы собираемся начать спрайт
в центре экрана.

496
00:29:45,970 --> 00:29:49,410
И теперь у нас есть х и скорость у и
они оба собираются начать с нуля.

497
00:29:49,410 --> 00:29:53,740

498
00:29:53,740 --> 00:29:55,880
>> Это неправильный файл.

499
00:29:55,880 --> 00:29:56,380
Прости.

500
00:29:56,380 --> 00:29:57,960
Так что все это правда.

501
00:29:57,960 --> 00:30:00,170
Это все еще в этом файле.

502
00:30:00,170 --> 00:30:03,210
У нас есть деление на 4, и все.

503
00:30:03,210 --> 00:30:07,830
Так вот у нас есть х и у позиции
для центра окна.

504
00:30:07,830 --> 00:30:12,480
И мы даем ему начальную скорость
этой постоянной скоростью, которая

505
00:30:12,480 --> 00:30:15,180
Я считаю, это 300 пикселей в секунду.

506
00:30:15,180 --> 00:30:19,850
Теперь у нас есть это INT может так же хорошо,
быть логическое называется рядом просил.

507
00:30:19,850 --> 00:30:23,970
И вместо того, Ведение
бесконечный цикл по таймеру здесь,

508
00:30:23,970 --> 00:30:29,180
мы собираемся анимировать, как
Пока близко не просил.

509
00:30:29,180 --> 00:30:30,960
>> Так как мы обрабатываем события?

510
00:30:30,960 --> 00:30:35,600
Ну, SDL очереди до событий в
буквальное очереди за кулисами.

511
00:30:35,600 --> 00:30:38,860
И тогда каждый кадр,
мы можем из очереди событий

512
00:30:38,860 --> 00:30:43,900
от этой очереди, используя
этот вызов SDL_PullEvent.

513
00:30:43,900 --> 00:30:46,730
И снова, определенно идти читать
об этом в документации.

514
00:30:46,730 --> 00:30:50,450
Там очень много больше деталей и много
больше функций вы можете использовать в этом.

515
00:30:50,450 --> 00:30:54,750
Мы передаем ей адрес
этой вещи, SDL_Event

516
00:30:54,750 --> 00:30:56,990
что мы имеем здесь в стеке.

517
00:30:56,990 --> 00:30:58,840
>> Теперь, что является SDL_event?

518
00:30:58,840 --> 00:31:02,356
Потому что SDL, если мы посмотрим в
в documentation-- давайте

519
00:31:02,356 --> 00:31:07,580
см, API по категориям, вход
События, обработка событий,

520
00:31:07,580 --> 00:31:15,150
мы можем посмотреть на количество
различных событий здесь

521
00:31:15,150 --> 00:31:18,600
и мы видим, что есть
в целом т из них.

522
00:31:18,600 --> 00:31:22,150
Так что это SDL_Event вещь?

523
00:31:22,150 --> 00:31:28,190

524
00:31:28,190 --> 00:31:31,107
SDL_Event является объединением.

525
00:31:31,107 --> 00:31:31,940
Ничего себе, что такое объединение?

526
00:31:31,940 --> 00:31:33,910
Вы вероятно никогда не
слышал, что раньше.

527
00:31:33,910 --> 00:31:35,610
И это нормально.

528
00:31:35,610 --> 00:31:39,420
>> Союз вроде как
на структуру, за исключением структуры

529
00:31:39,420 --> 00:31:41,960
имеет место для всех
его поля и памяти,

530
00:31:41,960 --> 00:31:45,060
в то время как союз только имеет
достаточно места, чтобы соответствовать самым крупным

531
00:31:45,060 --> 00:31:49,660
один из его полей, что означает его
может хранить только один из его полей

532
00:31:49,660 --> 00:31:52,830
в то время, какой вид
имеет смысл для событий, верно?

533
00:31:52,830 --> 00:31:55,810
Мы можем иметь клавиатуру
событие или мероприятие окно,

534
00:31:55,810 --> 00:31:59,750
но одно событие не может быть и
Мероприятие клавиатура и окно событий,

535
00:31:59,750 --> 00:32:05,450
так что было бы глупо иметь пространство для
и тех, кто внутри нашего союза событий.

536
00:32:05,450 --> 00:32:07,770
Так что, если вы хотите, чтобы
создать свой собственный союз,

537
00:32:07,770 --> 00:32:10,020
это выглядит точно так же,
как создание на структуру,

538
00:32:10,020 --> 00:32:14,140
кроме того, что мы используем ключевое слово союза
вместо слова структуры.

539
00:32:14,140 --> 00:32:17,490
И помните, для всех из
вещи внутри вашего союза,

540
00:32:17,490 --> 00:32:22,020
фактическая величина, объединение
может иметь только один из этих значений

541
00:32:22,020 --> 00:32:24,780
вовремя.

542
00:32:24,780 --> 00:32:29,940
>> Так как мы можем сказать, что это за события
мы просто выталкивается из этой очереди?

543
00:32:29,940 --> 00:32:33,370
Ну, мы можем проверить Event.type.

544
00:32:33,370 --> 00:32:35,792
И если это равно
чтобы SDL_Quit, мы знаем,

545
00:32:35,792 --> 00:32:37,500
это событие, которое
был создан, когда мы

546
00:32:37,500 --> 00:32:39,510
ударил, что X в углу окна.

547
00:32:39,510 --> 00:32:44,270
И мы можем установить рядом просил равна 1.

548
00:32:44,270 --> 00:32:47,230
В остальном это просто некоторые анимации
что вы видели раньше.

549
00:32:47,230 --> 00:32:52,802
Так что давайте идти вперед и сделать
это и увидеть, насколько хорошо она работает.

550
00:32:52,802 --> 00:32:55,135
Так что я собираюсь ввести марку и
Затем SRCS = hello5_events.c.

551
00:32:55,135 --> 00:33:03,760

552
00:33:03,760 --> 00:33:04,770
Там мы идем.

553
00:33:04,770 --> 00:33:05,780
Игры.

554
00:33:05,780 --> 00:33:08,920
>> Теперь мы можем видеть, что это было
действительно сократили в четыре раза.

555
00:33:08,920 --> 00:33:10,360
И теперь это подпрыгивая.

556
00:33:10,360 --> 00:33:14,630
У меня есть обнаружение столкновения
происходит с боковых сторон окна

557
00:33:14,630 --> 00:33:16,840
что мы можем взглянуть на.

558
00:33:16,840 --> 00:33:21,190
И то, что происходит, когда я иду, чтобы закрыть его?

559
00:33:21,190 --> 00:33:22,120
Он закрывает.

560
00:33:22,120 --> 00:33:22,740
Фантастика.

561
00:33:22,740 --> 00:33:24,290
Мы получили это событие.

562
00:33:24,290 --> 00:33:26,630
И мы справились.

563
00:33:26,630 --> 00:33:30,730
>> Итак, давайте посмотрим назад на код.

564
00:33:30,730 --> 00:33:33,020
Итак, как же я его
подпрыгивая, как, что?

565
00:33:33,020 --> 00:33:37,200
Помните, я установить оба х и
у первоначально скоростей.

566
00:33:37,200 --> 00:33:39,260
А скорость является положительным
постоянная, так что

567
00:33:39,260 --> 00:33:42,680
собирался сделать это, начиная из
идет вниз и вправо.

568
00:33:42,680 --> 00:33:45,680

569
00:33:45,680 --> 00:33:50,310
>> Теперь, каждый кадр, в дополнение к обработке
любые события, которые могли произойти,

570
00:33:50,310 --> 00:33:57,520
Я собираюсь обнаружить ли мой спрайт
пытается выйти из окна.

571
00:33:57,520 --> 00:34:03,610
Таким образом, мы можем сделать это, просто проверка
x_pos с 0, y_pos 0, а затем

572
00:34:03,610 --> 00:34:07,370
также x_pos и y_pos с
ширина и высота окна окно.

573
00:34:07,370 --> 00:34:11,010
Обратите внимание, я вычитается
ширина спрайта.

574
00:34:11,010 --> 00:34:14,090
И это потому, что, если я не сделал
вычесть ширину спрайта,

575
00:34:14,090 --> 00:34:17,760
это только проверить, что
происхождение спрайта

576
00:34:17,760 --> 00:34:19,690
не выходить за пределы окна.

577
00:34:19,690 --> 00:34:21,480
Но мы хотим, цельные
ширина спрайта

578
00:34:21,480 --> 00:34:24,030
чтобы всегда быть в окне и
вся высота спрайта

579
00:34:24,030 --> 00:34:25,321
чтобы всегда быть в окне.

580
00:34:25,321 --> 00:34:27,429
Так вот то, что вычитание для.

581
00:34:27,429 --> 00:34:30,080
Много геометрии здесь можно
полезно обратить его

582
00:34:30,080 --> 00:34:33,929
на бумаге с координатой
Система посмотреть, что происходит.

583
00:34:33,929 --> 00:34:38,090
>> Так что, если я сталкиваются, я просто
просто сбросить позицию

584
00:34:38,090 --> 00:34:41,400
так, что она не будет
из экрана.

585
00:34:41,400 --> 00:34:47,179
И я собираюсь, если он отскакивает
на одной из боковых стенок,

586
00:34:47,179 --> 00:34:51,469
Я собираюсь отрицать
х скорость, так что

587
00:34:51,469 --> 00:34:53,210
начинается подпрыгивая в другом направлении.

588
00:34:53,210 --> 00:34:56,210
И точно так же, если она попадает
верхней или нижней,

589
00:34:56,210 --> 00:34:59,820
Я собираюсь установить скорость у
равно отрицательной скорости у,

590
00:34:59,820 --> 00:35:01,690
так что оно вернется.

591
00:35:01,690 --> 00:35:03,860
Так что это просто, как мы получили это здесь.

592
00:35:03,860 --> 00:35:07,560
>> И обновление позиции
так же, как мы видели раньше,

593
00:35:07,560 --> 00:35:12,510
разделить на 60, потому что мы
только обработка 1/60 секунды.

594
00:35:12,510 --> 00:35:15,750
А потом рендеринга,
точно так же, как и раньше.

595
00:35:15,750 --> 00:35:19,810
И так, что все,
что происходит на этом файле.

596
00:35:19,810 --> 00:35:22,490
Так вот, как мы делаем события.

597
00:35:22,490 --> 00:35:29,260
Главное, чтобы забрать здесь
эта функция SDL_PullEvent.

598
00:35:29,260 --> 00:35:33,020
И вы должны, безусловно, читать
Документация больше о SDL_Event

599
00:35:33,020 --> 00:35:38,630
объединение, потому что этот тип данных является
очень, очень важно, потому что мы используем его

600
00:35:38,630 --> 00:35:40,690
для всех видов мероприятий.

601
00:35:40,690 --> 00:35:46,539
>> Например, мы используем его для клавиатуры
События, которые это то, что этот файл для.

602
00:35:46,539 --> 00:35:47,330
Так что мы имеем?

603
00:35:47,330 --> 00:35:50,180
У нас есть то же самое, как и прежде,
инициализации SDL, создать окно,

604
00:35:50,180 --> 00:35:55,260
создать визуализации, загрузить изображение
в память, создать текстуру.

605
00:35:55,260 --> 00:36:00,530
Опять же, мы собираемся
есть этот Dest прямоугольник,

606
00:36:00,530 --> 00:36:04,890
мы собираемся масштабировать изображение
на четыре, сделать его немного меньше.

607
00:36:04,890 --> 00:36:08,000
Теперь, мы собираемся, чтобы начать
спрайт в центре экрана.

608
00:36:08,000 --> 00:36:12,090
Но в этот раз, мы собираемся установить
Начальные х и у скорости к нулю,

609
00:36:12,090 --> 00:36:15,140
потому что клавиатура
будет контролировать их.

610
00:36:15,140 --> 00:36:18,900
И, кроме того, мы собираемся
отслеживать этих переменных

611
00:36:18,900 --> 00:36:20,450
вверх, вниз, влево и вправо.

612
00:36:20,450 --> 00:36:23,090
И что будет держать
трек ли мы имею

613
00:36:23,090 --> 00:36:27,370
нажатии кнопок клавиатуры, что
соответствуют вверх, вниз, влево,

614
00:36:27,370 --> 00:36:28,460
и правильно.

615
00:36:28,460 --> 00:36:32,440
>> Теперь, это своего рода фантазии
потому что мы можем использовать W, A, S,

616
00:36:32,440 --> 00:36:35,480
D здесь, или клавиш со стрелками фактические.

617
00:36:35,480 --> 00:36:38,590
Мы увидим, что всего за секунду.

618
00:36:38,590 --> 00:36:41,140
Итак, мы собираемся, чтобы обработать
событие, как и раньше.

619
00:36:41,140 --> 00:36:42,530
Тянем событие.

620
00:36:42,530 --> 00:36:45,840
Но теперь мы собираемся
перейти от типа события.

621
00:36:45,840 --> 00:36:47,710
Если это SDL_Quit, мы
собирается установить рядом

622
00:36:47,710 --> 00:36:49,990
просьба одного, как раньше.

623
00:36:49,990 --> 00:36:52,315
Это обрабатывает х в
угол окна,

624
00:36:52,315 --> 00:36:55,050
так что наше окно действительно закрывается.

625
00:36:55,050 --> 00:37:00,110
>> В противном случае, если мы получим SDL клавишу нажатой
событие, которое означает, что мы нажали клавишу,

626
00:37:00,110 --> 00:37:04,470
то, что мы собираемся сделать, это мы
собирается перейти на эту вещь здесь,

627
00:37:04,470 --> 00:37:11,370
который означает: так event.key
означает относиться наш союз событий,

628
00:37:11,370 --> 00:37:15,490
пойти и получить ключ
Структура событие в нем.

629
00:37:15,490 --> 00:37:18,810
Так что получается, что это
Союз является ключевой структурой событие.

630
00:37:18,810 --> 00:37:22,820
А потом перейти к ключу
Структура мероприятия его поле

631
00:37:22,820 --> 00:37:26,140
называется символ клавиши, а затем скан.

632
00:37:26,140 --> 00:37:29,480
И снова, определенно читал
документация об этом.

633
00:37:29,480 --> 00:37:31,220
Ключевое слово входы довольно интересно.

634
00:37:31,220 --> 00:37:34,020
Вы можете получить коды сканирования или ключевые коды.

635
00:37:34,020 --> 00:37:38,590
И это немного тонкие, но
документация довольно хорошо.

636
00:37:38,590 --> 00:37:43,380
>> Так что, если мы видим, что код для сканирования
наша нажмите клавишу быть Вт или вверх,

637
00:37:43,380 --> 00:37:45,450
мы собираемся создать, равное 1.

638
00:37:45,450 --> 00:37:47,240
И тогда мы вырваться из этой переключателя.

639
00:37:47,240 --> 00:37:52,980
Если это или влево, мы устанавливаем слева 1, ET
далее, и так далее, для вниз и вправо.

640
00:37:52,980 --> 00:37:57,080
Теперь, в этой внешней переключатель,
если мы видим ключ до события,

641
00:37:57,080 --> 00:38:00,730
это означает, что мы выпустили ключ
не, и мы больше не нажимая ее.

642
00:38:00,730 --> 00:38:05,380
Так что я собираюсь сказать, до равняется 0,
левый равен 0, 0 вниз равен, право

643
00:38:05,380 --> 00:38:08,260
равен 0, и так далее.

644
00:38:08,260 --> 00:38:12,070
>> И обратите внимание, у нас есть в каждом из них
два случая исправить рядом друг с другом

645
00:38:12,070 --> 00:38:14,490
без отдельного кода
в первом случае, который

646
00:38:14,490 --> 00:38:18,180
означает, что будь то
При S или прямо здесь,

647
00:38:18,180 --> 00:38:20,520
он собирается выполнить этот код.

648
00:38:20,520 --> 00:38:22,090
Так что это довольно удобно.

649
00:38:22,090 --> 00:38:24,830
Это предохраняет нас от необходимости делать больше
условия и IFS и вещи

650
00:38:24,830 --> 00:38:26,980
как это.

651
00:38:26,980 --> 00:38:29,420
>> Итак, мы собираемся, чтобы
определения скорости.

652
00:38:29,420 --> 00:38:31,020
Мы устанавливаем скорость в 0.

653
00:38:31,020 --> 00:38:33,910
Тогда при нажатии на
и не работает, то мы

654
00:38:33,910 --> 00:38:37,450
установить у скорость для отрицательного скорости.

655
00:38:37,450 --> 00:38:42,930
Запомнить отрицательным, потому что
отрицательное направление у вверх.

656
00:38:42,930 --> 00:38:45,540
И положительный у направление вниз.

657
00:38:45,540 --> 00:38:47,510
Если нажата
и не вверх, тогда мы

658
00:38:47,510 --> 00:38:53,860
собирается установить его на положительной скорости,
что означает идти вниз по экрану.

659
00:38:53,860 --> 00:38:55,460
То же самое с левой и правой.

660
00:38:55,460 --> 00:38:58,200
>> А потом мы собираемся обновить
позиции так же, как раньше.

661
00:38:58,200 --> 00:39:00,740
Мы собираемся сделать столкновения
Обнаружение с оценками,

662
00:39:00,740 --> 00:39:04,290
но мы не собираемся, чтобы сбросить
Скорость, поскольку скорость всего

663
00:39:04,290 --> 00:39:06,780
управляется клавиатурой.

664
00:39:06,780 --> 00:39:11,230
Но мы собираемся сбросить
позиции, чтобы держать его в окне.

665
00:39:11,230 --> 00:39:14,400
И мы собираемся, чтобы установить
позиции в структуры

666
00:39:14,400 --> 00:39:17,400
а затем сделать все
оказание вещи от до.

667
00:39:17,400 --> 00:39:20,750
Итак, давайте посмотрим, что он делает.

668
00:39:20,750 --> 00:39:25,460
Так что SRCS-- давайте посмотрим,
это hello6_keyboard.c.

669
00:39:25,460 --> 00:39:38,140

670
00:39:38,140 --> 00:39:38,820
>> О нет.

671
00:39:38,820 --> 00:39:40,150
Таким образом, мы получили некоторые предупреждения здесь.

672
00:39:40,150 --> 00:39:43,840
И это просто говорит мы не
проверить для каждого возможного вида

673
00:39:43,840 --> 00:39:45,610
события.

674
00:39:45,610 --> 00:39:49,470
Это нормально, потому что
есть 236 из них, или так.

675
00:39:49,470 --> 00:39:51,760
Так что я собираюсь игнорировать эти предупреждения.

676
00:39:51,760 --> 00:39:53,530
Он по-прежнему составлен хорошо.

677
00:39:53,530 --> 00:39:56,100
Так что я собираюсь играть в эту игру.

678
00:39:56,100 --> 00:39:57,590
Это не движется.

679
00:39:57,590 --> 00:40:04,150
Но теперь, когда я пюре на моей клавиатуре,
Я могу сделать какое-то движение WASD здесь,

680
00:40:04,150 --> 00:40:06,870
Я также использовать мои клавиш со стрелками.

681
00:40:06,870 --> 00:40:10,070
И заметьте, даже если я
нажатию правой прямо сейчас,

682
00:40:10,070 --> 00:40:13,804
это не выходя из окна,
потому что я сбросить его на каждом кадре.

683
00:40:13,804 --> 00:40:14,720
Так что это довольно опрятно.

684
00:40:14,720 --> 00:40:19,420
Вы можете себе представить, двигаясь вокруг Марио с
некоторые клавиши со стрелками или что-то подобное.

685
00:40:19,420 --> 00:40:22,880
И да, Х делает работу.

686
00:40:22,880 --> 00:40:26,900
>> Так конечный файл мы собираемся
смотреть, hellow7_mouse.

687
00:40:26,900 --> 00:40:29,600
Это о получении ввод мыши.

688
00:40:29,600 --> 00:40:34,790
Таким образом, в этом, мы
импортировать математическую заголовок,

689
00:40:34,790 --> 00:40:38,100
потому что мы собираемся, чтобы иметь
немного математики здесь.

690
00:40:38,100 --> 00:40:45,260
Все та же старая, те же старые вещи, назначения,
то же самое старое, видел, что раньше.

691
00:40:45,260 --> 00:40:46,910
Ну, это интересно.

692
00:40:46,910 --> 00:40:51,730
Так мы вернулись только проверка
для SDL бросить событие.

693
00:40:51,730 --> 00:40:52,460
Почему это?

694
00:40:52,460 --> 00:40:55,110
Таким образом, вы можете получить ввод мыши с событиями.

695
00:40:55,110 --> 00:40:57,670
Например, когда мышь перемещается,
Вы получаете событие для этого.

696
00:40:57,670 --> 00:41:00,520
При нажатии кнопки мыши,
Вы можете получить событие для этого.

697
00:41:00,520 --> 00:41:05,760
>> Но есть еще один, несколько проще
возможно, API для получения ввод мыши.

698
00:41:05,760 --> 00:41:09,500
И это просто SDL состояние Get мыши.

699
00:41:09,500 --> 00:41:14,370
Так у меня есть Int для х и
у для позиции курсора.

700
00:41:14,370 --> 00:41:18,910
Я передать его SDL_GetMouseState,
которая устанавливает их.

701
00:41:18,910 --> 00:41:22,200
И это положение в
систему координат окна.

702
00:41:22,200 --> 00:41:25,520
Таким образом, если масса в левом верхнем углу
окна, что бы 0, 0.

703
00:41:25,520 --> 00:41:28,040

704
00:41:28,040 --> 00:41:33,380
>> Теперь, что я собираюсь сделать, это я собираюсь
чтобы сделать немного векторной математики.

705
00:41:33,380 --> 00:41:36,910
Бьюсь об заклад, вы думали, не будет
Видно, что в CS50, но здесь это.

706
00:41:36,910 --> 00:41:40,720
Я собираюсь сделать некоторые вектор
математика, чтобы получить вектор

707
00:41:40,720 --> 00:41:43,840
от изображения на курсор.

708
00:41:43,840 --> 00:41:53,280
И так почему я должен
это вычитание здесь?

709
00:41:53,280 --> 00:42:01,350
Ну, если я просто использовал Dest .-- так
Мне нужно, чтобы перевести мыши х

710
00:42:01,350 --> 00:42:05,166
и у на половину ширины и
высота изображения,

711
00:42:05,166 --> 00:42:08,040
потому что я хочу центре
изображение, которое будет идти к мыши,

712
00:42:08,040 --> 00:42:10,160
не происхождение образа.

713
00:42:10,160 --> 00:42:15,650
>> Так что это просто, чтобы убедиться, что я говорю
о центре картинки здесь.

714
00:42:15,650 --> 00:42:19,510
Тогда мы получим треугольник х и у, что
разница от цели

715
00:42:19,510 --> 00:42:23,430
с фактическим положением изображения.

716
00:42:23,430 --> 00:42:25,690
И тогда мы можем получить
расстояние здесь, что

717
00:42:25,690 --> 00:42:29,140
будет Пифагора
Теорема, корень квадратный из х

718
00:42:29,140 --> 00:42:32,720
раз х плюс у раз у.

719
00:42:32,720 --> 00:42:38,400
>> Теперь, чтобы предотвратить дрожание, и я могу показать
Вы что это делает, если я не делаю этого,

720
00:42:38,400 --> 00:42:45,830
если расстояние между курсором и
центр изображения меньше, чем пять,

721
00:42:45,830 --> 00:42:48,730
Я просто не собираюсь, чтобы переместить изображение.

722
00:42:48,730 --> 00:42:52,900
В противном случае, мы устанавливаем скорость.

723
00:42:52,900 --> 00:42:55,960
И мы установите его так, что
скорость всегда будет постоянной.

724
00:42:55,960 --> 00:42:58,770
И конечный результат всего
это математика, что изображения

725
00:42:58,770 --> 00:43:01,660
будет двигаться в направлении курсора.

726
00:43:01,660 --> 00:43:08,470
>> Теперь, получается, что
SDL_GetMouseState,

727
00:43:08,470 --> 00:43:14,490
в дополнение к установив
х и у аргументы здесь,

728
00:43:14,490 --> 00:43:21,340
он также возвращает Int, что соответствует
в состоянии кнопок мыши.

729
00:43:21,340 --> 00:43:24,600
Таким образом, мы не читаем, что
непосредственно, но мы можем

730
00:43:24,600 --> 00:43:29,090
использовать эти макросы, один
побитовое оператор, не страшно,

731
00:43:29,090 --> 00:43:30,650
только побитовое и.

732
00:43:30,650 --> 00:43:38,320
Поэтому мы говорим, кнопки, которая является результатом
нашей SDL_GetMouseState, если

733
00:43:38,320 --> 00:43:43,990
и побитовое и этот макрос
здесь, SDL_BUTTON_LEFT.

734
00:43:43,990 --> 00:43:47,680
>> Так что это будет просто решить
в растровом изображении, что соответствует

735
00:43:47,680 --> 00:43:51,090
в левой кнопкой мыши нажата.

736
00:43:51,090 --> 00:43:55,470
И поэтому, если побитовое
и происходит, и это

737
00:43:55,470 --> 00:43:59,340
не равен нулю, что означает,
оставили была нажата кнопка,

738
00:43:59,340 --> 00:44:04,320
то мы на самом деле происходит, чтобы свести на нет
и х и у скорости,

739
00:44:04,320 --> 00:44:06,700
который будет просто сделать изображение побег.

740
00:44:06,700 --> 00:44:07,980
Обновление позиции.

741
00:44:07,980 --> 00:44:10,920
Столкновения обнаружений, видел его
все прежде, рендеринга, все в порядке.

742
00:44:10,920 --> 00:44:11,510
Давайте сделаем это.

743
00:44:11,510 --> 00:44:14,200

744
00:44:14,200 --> 00:44:16,050
Таким образом, вы получили сделать SRCS = hello7_mouse.c.

745
00:44:16,050 --> 00:44:21,720

746
00:44:21,720 --> 00:44:22,220
Отлично.

747
00:44:22,220 --> 00:44:23,490
Нет ошибок.

748
00:44:23,490 --> 00:44:24,900
И игра.

749
00:44:24,900 --> 00:44:26,440
>> Так вот у меня есть мышь.

750
00:44:26,440 --> 00:44:29,000
И образ действительно
чеканка мышь.

751
00:44:29,000 --> 00:44:33,140
Теперь, в игре вы делаете, может быть,
это как вражеского чеканка

752
00:44:33,140 --> 00:44:35,240
ваш маленький символ или что угодно.

753
00:44:35,240 --> 00:44:37,440
Но здесь у нас есть
чеканка изображения мышью.

754
00:44:37,440 --> 00:44:41,000
И когда я нажмите, мышь
начинается чеканка изображение

755
00:44:41,000 --> 00:44:42,860
и изображение
убегая от мыши.

756
00:44:42,860 --> 00:44:43,810
Так что это довольно прохладно.

757
00:44:43,810 --> 00:44:47,770
И заметьте снова, есть
еще обнаружение столкновения здесь.

758
00:44:47,770 --> 00:44:53,930
>> Так что это финал немного
демо я создал здесь.

759
00:44:53,930 --> 00:44:58,870
И давайте взглянем на еще одну вещь.

760
00:44:58,870 --> 00:45:02,970
Итак, вернемся сюда, я упомянул этот дрожание.

761
00:45:02,970 --> 00:45:05,000
Отлично.

762
00:45:05,000 --> 00:45:12,890
Так что, если расстояние меньше, чем пять пикселей,
Я сидел х и у скорость до нуля.

763
00:45:12,890 --> 00:45:15,960
Что произойдет, если мы избавиться от этого?

764
00:45:15,960 --> 00:45:19,070
Так что я собираюсь сделать это просто.

765
00:45:19,070 --> 00:45:23,820

766
00:45:23,820 --> 00:45:30,150
Пожалуйста, простите эту ужасающую стиль,
но мы закомментировано правильный код.

767
00:45:30,150 --> 00:45:38,080
Так что я собираюсь спасти и сделать
Та же команда из прежде чем сделать это.

768
00:45:38,080 --> 00:45:38,785
>> Отлично.

769
00:45:38,785 --> 00:45:39,660
А теперь что происходит?

770
00:45:39,660 --> 00:45:43,260

771
00:45:43,260 --> 00:45:43,760
Хорошо.

772
00:45:43,760 --> 00:45:45,801
Мы по-прежнему следуя
мыши, как и раньше,

773
00:45:45,801 --> 00:45:49,310
но когда мы добираемся до мыши,
мы получили это грубое дрожание.

774
00:45:49,310 --> 00:45:50,320
Что там происходит?

775
00:45:50,320 --> 00:45:52,600
Ну, в нашем векторе
математика, помню, мы были

776
00:45:52,600 --> 00:45:57,540
принимая расстояние между
курсор и центр изображения?

777
00:45:57,540 --> 00:46:00,710
Ну, как то, что подходит
0, мы начинаем получать

778
00:46:00,710 --> 00:46:06,280
как такого рода поведение сумасшедшего
где изображение является своего рода

779
00:46:06,280 --> 00:46:08,910
как колеблется вокруг курсора.

780
00:46:08,910 --> 00:46:12,000
И это создает этот дрожание.

781
00:46:12,000 --> 00:46:13,020
И это действительно некрасиво.

782
00:46:13,020 --> 00:46:15,103
И вы, вероятно, не
хотите, чтобы ваши игры делает, что

783
00:46:15,103 --> 00:46:17,350
если это не какой-то особый эффект.

784
00:46:17,350 --> 00:46:21,960
>> Так вот почему у нас есть
только в этом произвольное

785
00:46:21,960 --> 00:46:27,150
отрезать пяти пикселей, где мы говорим,
если это в течение пяти пикселей, мы хорошо.

786
00:46:27,150 --> 00:46:29,560
Нам не нужно, чтобы переместить изображение больше.

787
00:46:29,560 --> 00:46:32,260
Так вот то, что там происходит.

788
00:46:32,260 --> 00:46:37,390

789
00:46:37,390 --> 00:46:40,870
>> Так что это довольно много его.

790
00:46:40,870 --> 00:46:44,390
Теперь вы знаете, как создать
окно, загрузить изображение,

791
00:46:44,390 --> 00:46:49,330
нарисовать изображение в окне, получить
ввод с клавиатуры, мыши получить ввод,

792
00:46:49,330 --> 00:46:52,190
есть куча других
вход, что вы не

793
00:46:52,190 --> 00:46:56,070
знаете, как получить, если вы просто провести
Несколько минут, глядя на документации.

794
00:46:56,070 --> 00:46:59,670
Таким образом, вы на самом деле имеют довольно
несколько инструментов в вашем распоряжении теперь

795
00:46:59,670 --> 00:47:01,650
написать полноценную игру.

796
00:47:01,650 --> 00:47:05,030
>> Теперь, каждая игра необходим аудио,
но звук документация

797
00:47:05,030 --> 00:47:06,460
также довольно хорошо.

798
00:47:06,460 --> 00:47:09,200
И я готов поспорить, что если
Вы понимаете, все вещи,

799
00:47:09,200 --> 00:47:14,560
мы говорили о сегодня с
изображения и поверхности,

800
00:47:14,560 --> 00:47:18,370
окна, и все то,
выяснить аудио API не

801
00:47:18,370 --> 00:47:21,170
будет, что плохо.

802
00:47:21,170 --> 00:47:27,420
Так что я с нетерпением жду встречи
что вы создаете с SDL.

803
00:47:27,420 --> 00:47:31,595