Четверг, 30 марта 2017, 05:34

Приветствую Вас Гость

Меню сайта
Категории каталога
Создание игр [298]
Статьи об общих понятиях связанных с созданием игр.
Программирование [66]
Гайды по программированию на разных ЯП.
Движки и Гейммейкеры [120]
Статьи о программах для создания игр, уроки и описания.
Софт [27]
Различные программы, в том числе в помощь игроделам.
2D-графика [7]
Уроки по рисованию, растр, пиксель-арт, создание спрайтов и пр.
3D-графика [8]
Уроки по моделированию, ландшафт, модели, текстурирование и пр.
Моддинг игр [4]
Модификация компьютерных игр, создание дополнений, перевод, хакинг.
Игры [65]
Статьи об играх, в том числе и сделанных на гейммейкерах.
Разное [53]
Статьи, которые не вошли в определённые разделы.
Наш опрос
Разработка игр для вас:
Всего ответов: 10616
Главная » Статьи » Создание игр

Основы 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

    Теперь надо увеличить значение положения прямоугольника по оси х на скорость прямоугольника в текущем кадре, и если положение прямоугольника больше чем размер экрана, то переместим прямоугольник на значение “ - размер прямоугольника по оси х”, вот код который нужно вписать в раздел формирования кадра:
    Code
    rect.x += dm
    if rect.x > 600:
      rect.x = - rect.width

    Ну и осталось только нарисовать прямоугольник методом pygame.draw.rect():
    Code
    pygame.draw.rect(screen,rect_color,rect)

    Ну, вот и все, теперь можно запустить программу и проверить, как она работает. Запускаем и видим то, что прямоугольник двигается по экрану со скоростью 250 px в секунду.

    Ну, а в итоге, должен быть написан следующий код в файле “pygame_anim_temp.py”:

    Часть 2. Введение в класс Rect.

    Ну а теперь рассмотрим класс 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. Так что в блоке инициализации данных описываем следующий код:

    Code
    rect_1 = Rect((0,0),(100,100))
    rect_1_color = (255,0,0)

    Как видно по коду сначала создается прямоугольник размером 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. Давайте напишем все наши действия в блоке инициализации данных:
    Code
    rect_2 = rect_1.copy()
    rect_2.move_ip(0,150)
    rect_3 = rect_1.move(150,0)

    Как видно, сначала, мы создаем полную копию объекта 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:
    Code
    pygame.draw.rect(screen, rect_2_color, rect_2)
    pygame.draw.rect(screen, rect_3_color, 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
    rect_4 = rect_1.inflate(-10,-10)
    rect_4_color = (255,255,0)

    Осталось нарисовать этот прямоугольник в блоке формирования кадра:
    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, который будет включать в себя площадь всех прямоугольников. Пишем код в блоке инициализации:
    Code
    rect_6 = rect_1.unionall((rect_2,rect_3,rect_4,rect_5))

    Теперь для наглядности изменим размер этого прямоугольника на 10px относительно центра, и объявим для него цвет фиолетового цвета:
    Code
    rect_6.inflate_ip(10,10)
    rect_6_color = (255,0,255)

    Теперь надо отобразить его в кадре, для этого перед отображением прямоугольника 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:
    Code
    rect_7 = Rect(300,0,100,100)
    rect_7_color = (128,128,128)

    Теперь давайте передвинем копию прямоугольника rect_4 внутрь прямоугольника rect_7. Также для этого прямоугольника объявим черный цвет. Пишем код в блоке инициализации:
    Code
    rect_8 = rect_4.clamp(rect_7)
    rect_8_color = (0,0,0)

    Теперь рисуем эти два прямоугольника, для этого в блок формирования кадра добавляем следующий код:
    Code
    pygame.draw.rect(screen, rect_7_color, rect_7)
    pygame.draw.rect(screen, rect_8_color, rect_8)

    Запускаем и смотрим что получилась. Как видно копия прямоугольника 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) | Автор: Карпенко Евгений
    Просмотров: 6286 | Рейтинг: 5.0/3 |
    Теги: Основы Pyame, Уроки по PyGame, Pygame, noTformaT, Анимация в Pygame
    Дополнительные опции:
    Также если вы считаете, что данный материал мог быть интересен и полезен кому-то из ваших друзей, то вы бы могли посоветовать его, отправив сообщение на e-mail друга:

    Игровые объявления и предложения:
    Если вас заинтересовал материал «Основы PyGame. Прямоугольные области в PyGame. Часть первая.», и вы бы хотели прочесть что-то на эту же тему, то вы можете воспользоваться списком схожих материалов ниже. Данный список сформирован автоматически по тематическим меткам раздела. Предлагаются такие схожие материалы: Если вы ведёте свой блог, микроблог, либо участвуете в какой-то популярной социальной сети, то вы можете быстро поделиться данной заметкой со своими друзьями и посетителями.

    Всего комментариев: 0
    Добавлять комментарии могут только зарегистрированные пользователи.
    [ Регистрация | Вход ]
    Поиск
    10 случайных движков
  • JumpCraft
  • J.U.R.P.E.
  • Defold
  • Horde3D
  • EDGE
  • WindMill
  • Havok Vision
  • DGLEngine
  • Vavoom
  • Amp II Game Engine
  • Друзья сайта
    Игровой форум GFAQ.ru Перевод консольных игр
    GameDev, Уроки OpenGL, Программирование, Создать Minecraft
    Все права сохранены. GcUp.ru © 2008-2017 | Free GIF Animator Рейтинг