Основы PyGame. Прямоугольные области в PyGame. Часть первая.
Основы PyGame. Прямоугольные области в PyGame. Доброго времени суток, уважаемые участники ресурса GcUp! В этой статье рассмотрим прямоугольные области в PyGame и методы для работы с ними.
Перед изучением статьи читатель должен знать следующие вещи:
Знание синтаксиса и семантики языка Python ветки 2.х. (Если знаете С/С++, Java, PHP и т.д но не знаете Python то лучше не начинать изучать эти статьи, это разные языки и ничего общего у Python’a с ними нет).
Знание основ работы в IDLE(Python GUI) или умение запускать и редактировать программы на языке Python в других средах разработки.
Знание основных типов данных языка Python ветки 2.х. (числа, строки, последовательности/списки, словари, кортежи).
Умение работать в операционной системе Windows.
Логически эта статья будет разделена на следующие блоки:
Введение в анимацию.
Введение в класс Rect.
Методы класса Rect.
Пересечение и столкновение прямоугольных областей.
Заключение. На этом все, приступим к изучению библиотеки PyGame.
Часть первая. Введение в анимацию.
Начнем с анимации, вернее с анимации, которая базируется на времени, ее часто называют “Time Based Animation”. Этот тип анимации зависит от времени. В нашем мире практически все измеряется в секундах, поэтому наш тип анимации тоже будет зависеть от секунд. Принцип такого типа анимации в следующем – главное знать скорость изменения свойства объекта в одну секунда, то есть если мы хотим переместить объект с точки “а” в точку “b” за определенное количество секунд, то мы должны знать скорость объекта в секундах. Для того чтобы понять это давайте попробуем сделать простую “Time Based” анимацию. Для начала открываем написанный нами раньше шаблон “pygame_template.py”. Сохранять мы его не будем, сейчас нам надо переделать его под “Time Based” анимацию. Нам надо узнать время, для этого мы создадим объект “clock”, этот объект возвращает время, но только в миллисекундах, а нам надо время в секундах, для этого мы объявим еще две переменные – “milli” и “seconds”, в которых будем хранить время, за которое сформировался предыдущих кадр. Так что, в разделе инициализации пишем следующий код:
Code
clock = pygame.time.Clock() milli = seconds = 0.0
Теперь надо узнать количество секунд, за которых произошло формирование предыдущего кадра, для этого нам понадобится метод Clock.tick(framerate=0): return, этот метод возвращает количество миллисекунд после предыдущего вызова этого метода (*ВНИМАНИЕ* - Если у вас очень медленный компьютер, то в параметре framerate, укажите число 40), но так как нам надо узнать количество секунд, то мы просто разделим на количество миллисекунд в секунде (в следующих статьях мы с вами подробней рассмотрим этот метод), поэтому перед блоком формирования кадра, а точнее перед строчкой screen.fill(windows_bgcolor) вставим следующий код:
Code
milli = clock.tick() seconds = milli / 1000.0
Вот и все, теперь мы знаем, сколько секунд формировался предыдущий кадр. Теперь можем сохранить шаблон “pygame_template.py”. В итоге в файле “pygame_template.py” должен быть следующий код:
Теперь давайте попробуем использовать новый шаблон для создания простой анимации передвижения прямоугольника с точки “а” в точку “б” по оси Х. Для начала откроем шаблон “pygame_template.py”, и сохраним его под именем “pygame_anim_temp.py” и изменим заголовок окна на “Simple Anim”. Теперь нам надо объявить сам прямоугольник - rect, скорость передвижения прямоугольника в секунду – speed_by_second, и цвет прямоугольника – rect_color, вот код из блока инициализации:
Code
rect = Rect(0,0,100,100) rect_color = (0,0,255) speed_by_second = 250
Как видно скорость передвижения равна 250, цвет прямоугольника – синий, и размер прямоугольника 100х100. Дальше в этой статье мы с вами разберем класс Rect и его конструкторы. Теперь надо вычислить скорость движения прямоугольника в кадре, для этого введем переменную dm и будем использовать следующую формулу – “скорость в кадре = скорость в секунду * количество секунд прошедшее в результате формирования предыдущего кадра”, так что пишем после блока расчета время формирования кадра следующий код:
Code
dm = speed_by_second * seconds
Теперь надо увеличить значение положения прямоугольника по оси х на скорость прямоугольника в текущем кадре, и если положение прямоугольника больше чем размер экрана, то переместим прямоугольник на значение “ - размер прямоугольника по оси х”, вот код который нужно вписать в раздел формирования кадра:
Ну и осталось только нарисовать прямоугольник методом pygame.draw.rect():
Code
pygame.draw.rect(screen,rect_color,rect)
Ну, вот и все, теперь можно запустить программу и проверить, как она работает. Запускаем и видим то, что прямоугольник двигается по экрану со скоростью 250 px в секунду.
Ну, а в итоге, должен быть написан следующий код в файле “pygame_anim_temp.py”:
Ну а теперь рассмотрим класс Rect. Это класс используется для хранения и управлением прямоугольных областей. Объект этого класса может быть создан из словосочетаний следующих свойств - left, top, width, и height. Так же можно создать объект Rect из другого объекта. Для объектов Rect есть несколько конструкторов, вот весь список:
pygame.Rect(left, top, width, height): return Rect
pygame.Rect((left, top), (width, height)): return Rect Как видно все конструкторы возвращают объект класса Rect, и параметры у них практически одинаковые, давайте рассмотрим первый конструктов pygame.Rect(left, top, width, height): return Rect, тут left – положение верхней левой точки прямоугольника по оси х, top – положение верхней левой точки по оси у, width – ширина прямоугольной области, height – высота прямоугольной области. У второго конструктора параметры такие же, как и у первого, вот только во втором используется два кортежа сформированные из параметров. Ширина и высота прямоугольной области может иметь значение 0, но тогда он вернет значение True, если использовать выражение сравнивания его с “не” None. Некоторые методы могут вернуть объект класса Rect с размером 0, при этом прямоугольник является недействительным. Объект Rect имеет несколько виртуальных атрибутов, которые могут быть использованы для перемещения и выравнивания: top, left, bottom, right topleft, bottomleft, topright, bottomright midtop, midleft, midbottom, midright center, centerx, centery size, width, height w,h Область, указанная в Rect, не включает в себя правой и нижней границы в 1px. Если нижняя граница Rect является верхней границей другого Rect (то есть, rect1.bottom = rect2.top), они перекрываются на экране, но не перекрываются когда происходит проверка на столкновение. Ну а теперь можно исследовать методы класса Rect.
Часть 3. Методы класса Rect.
Эта часть статьи как вы поняли, будет практической. Давайте сначала приготовим файл, в котором будем писать код. Открываем файл “pygame_template.py”и сохраняем его под именем “pygame_rect.py”, также меняем имя строку заголовка окна на "PyGame Rect". Теперь все готово, давайте сначала попробуем создать объект класса Rect с названием rect_1, используя первый конструктор, так же нам понадобится цвет прямоугольника - rect_1_color. Так что в блоке инициализации данных описываем следующий код:
Как видно по коду сначала создается прямоугольник размером 100х100, и начальная точка имеет координаты (0,0), так же определен красный цвет. Теперь надо отобразить созданный нами объект, будем делать это через метод pygame.draw.rect(), этот метод мы уже разбирали в предыдущих статьях, поэтому проблем с ним быть не должно, теперь пишем в блоке формирования код отображения объекта:
Code
pygame.draw.rect(screen, rect_1_color, rect_1)
Теперь запустим код и проверим, рисуется ли прямоугольник или нет. Как видно, рисуется в левом верхнем углу красный прямоугольник размером 100х100.
Ну а теперь приступим к изучению методов класса Rect. Первый метод это pygame.rect.copy(): return Rect, этот метод создает копию объекта, то есть возвращает полную его копию. Но для начала нам надо понять, то, что некоторые методы работают с самим объектом, а некоторые создают его копию и работают уже с копией, методы которые работают с самим объектом, имеют окончание “_ip”. Для того чтобы это понять давайте рассмотрим следующие методы:
Code
pygame.rect.move(x, y): return Rect pygame.rect.move_ip(x, y): return None
Как видно параметры методов одинаковы, сам метод передвигает прямоугольную область на определенное количество пикселей, которое указано в параметре, где х – количество пикселей по оси у, у – количество пикселей по оси у. Вот только первый создает копию объекта и перемещает его, а второй перемещает сам объект. Давайте попробуем использовать эти два метода, чтобы лучше понять их действия. Объявим две прямоугольные области rect_2 и rect_3, а также цвета для них rect_2_color, rect_3_color. Для того чтобы не создавать опять объект rect_2 мы просто сделаем его копией объекта rect_1, далее мы передвинем его на 150 пикселей по оси у используя метод Rect.move_ip, а с объектом rect_2 поступим немного по другому, мы опять не будем создавать объект с помощью конструктора, мы просто скопируем объект rect_1 и передвинем его с помощью метода Rect.move. Давайте напишем все наши действия в блоке инициализации данных:
Как видно, сначала, мы создаем полную копию объекта rect_1, а потом передвигаем его на 150px по оси у. С объектом rect_3 все проще, мы всего одной строчкой кода создаем полную копию объекта rect_1 и передвигаем эту копию на 150 px по оси х. Теперь надо определить цвета для прямоугольных областей, пусть они будут зеленого и синего света. Вот код их инициализации:
Code
rect_2_color = (0,255,0) rect_3_color = (0,0,255)
Теперь осталось только добавить код в блок формирования кадра, в котором будет рисоваться прямоугольники rect_2 и rect_3:
Теперь можно запустить код и проверить результат, как видно все работает отлично, в кадре рисуется три прямоугольника:
Надеюсь, что по примеру выше вы поняли, чем отличаются методы с окончанием “_ip” и без него, главное понять то, что методы с окончанием “_ip” работают именно с объектом, а не возвращают обработанную копию объекта. В примерах ниже мы будем использовать методы без окончания “_ip”, так как эти два метода практически идентичны и нам не надо писать дополнительные строчки кода инициализации объектов с помощью конструкторов, мы просто будем работать с копиями объекта rect_1. Ну а теперь рассмотрим следующие методы:
pygame.rect.inflate(x, y): return Rect
pygame.rect.inflate_ip(x, y): return None Методы изменяют размер прямоугольника относительно его центра, где х – изменение размера по оси х, у – изменение размера по оси у. В параметрах указывается количество пикселей, на сколько надо изменить размер прямоугольника, если указывается отрицательное число, то прямоугольник сократится в размерах. Давайте определим копию прямоугольника rect_1 желтого цвета, но уменьшим его размеры на 10px относительно центра. Вот код из блока инициализации данных:
Осталось нарисовать этот прямоугольник в блоке формирования кадра:
Code
pygame.draw.rect(screen, rect_4_color, rect_4)
Теперь можно запустить и проверить что произошло, как видно копия первого прямоугольника стала на 10px меньше оригинала относительно центра прямоугольника:
Следующие методы это: pygame.rect.union(Rect): return Rect pygane.rect.union_ip(Rect): return None Этот метода возвращает прямоугольник, который полностью покрывает площадь двух прямоугольников. Второй прямоугольник указывается в параметре. Давайте попробуем применить этот метод на практике, объединим красный и зеленый прямоугольник, и полученый прямоугольник увеличим на 10px для наглядного примера. Так как красный прямоугольник это объект rect_1, а зеленый это объект rect_2, а нам надо создать новый объект и объединить rect_1 и rect_2 то будем использовать метод pygame.rect.union для объекта rect_1. Цвет нового прямоугольника буде голубова цвета. Также изменим размер нового прямоугольника на 10px, это для наглядного отображения прямоугольника. Так что в блоке инициализации данных пишем код: rect_5 = rect_1.union(rect_2) rect_5.inflate_ip(10,10) rect_5_color = (0,255,255) Теперь надо нарисовать прямоугольник в кадре, для этого в блоке формирования кадра перед рисованием первого прямоугольника пишем код рисования нового прямоугольника: pygame.draw.rect(screen, rect_5_color, rect_5) Запускаем код и видим, что пятый прямоугольник занимает всю площадь, в которую входит первый и второй прямоугольник.
Следующий метод на очереди это Rect.unionall (Rect_sequence): return Rect, где Rect_sequence – кортеж из прямоугольников. Этот метод возвращает прямоугольник, который полностью покрывает площадь всех прямоугольников, указанных в кортеже и площадь прямоугольника метод, которого вызван. Этот метод чем-то похож на метод выше, только тут уже используется кортеж. Давайте попробуем создать прямоугольник rect_6, который будет включать в себя площадь всех прямоугольников. Пишем код в блоке инициализации:
Теперь надо отобразить его в кадре, для этого перед отображением прямоугольника rect_5 пишем следующий код:
Code
pygame.draw.rect(screen, rect_6_color, rect_6)
Запускаем и смотрим что получилось. Как видно рисуется фиолетовый прямоугольник, который занимает площадь всех прямоугольников увеличенный на 10 px:
Теперь рассмотрим метод Rect.fit(Rect): return Rect, этот метод возвращает новый прямоугольник, который перемещается и изменяется в соответствии другого прямоугольника. Метод чем-то похож на метод Rect.clamp. Давайте рассмотрим Rect.clamp(Rect): return Rect, у этого метода есть также окончание “_ip”, сам метод возвращает новый прямоугольник, центр которого переезжает в центр аргумента, если он больше самого аргумента, иначе прямоугольник просто переезжает внутрь аргумента. Давайте посмотрим, как работает это метод. Объявим прямоугольник серого цвета – rect_7, он будет начинаться в координатах 200,0 и иметь размер 100х100:
Теперь давайте передвинем копию прямоугольника rect_4 внутрь прямоугольника rect_7. Также для этого прямоугольника объявим черный цвет. Пишем код в блоке инициализации:
Запускаем и смотрим что получилась. Как видно копия прямоугольника rect_4 переместилась внутрь прямоугольника rect_7, но переместилась не в центр, так как прямоугольник rect_8 меньше чем rect_7:
Попробуйте изменить эту строчку кода:
Code
rect_8 = rect_4.clamp(rect_7)
на
Code
rect_8 = rect_6.clamp(rect_7)
Запустите и посмотрите что получилось:
Можно увидеть то что, центр копии rect_6 передвинулся в центр прямоугольника rect_7.
Как видно статья очень большая и GcUp не может ее потдерживать в полном виде, поэтому мне пришлось разделить ее на две части. Продолжение тут.
Категория: Создание игр | Добавил: noTformaT (20 Марта 2011)
| Автор: Карпенко Евгений
Просмотров: 18235
| Рейтинг: 4.7/9 |
Теги:
Дополнительные опции:
Также если вы считаете, что данный материал мог быть интересен и полезен кому-то из ваших друзей, то вы бы могли посоветовать его, отправив сообщение на e-mail друга:
Игровые объявления и предложения:
Если вас заинтересовал материал «Основы PyGame. Прямоугольные области в PyGame. Часть первая.», и вы бы хотели прочесть что-то на эту же тему, то вы можете воспользоваться списком схожих материалов ниже. Данный список сформирован автоматически по тематическим меткам раздела.
Предлагаются такие схожие материалы:
Если вы ведёте свой блог, микроблог, либо участвуете в какой-то популярной социальной сети, то вы можете быстро поделиться данной заметкой со своими друзьями и посетителями.
Всего комментариев: 0
Добавлять комментарии могут только зарегистрированные пользователи. [ Регистрация | Вход ]
