Python-сообщество

 boll.py
#! /usr/bin/env python3
# coding: utf8
import pygame
from pygame.sprite import Sprite
class Booll(pygame.sprite.Sprite):
    """Создает шар"""
    
    def __init__(self, ai_set, screen_game):
        """Создает шар и задает его начальную позицию"""
        super(Booll, self).__init__()
        self.screen = screen_game
        self.ai_set = ai_set
        
        # Загрузка изображения шара.
        self.image = pygame.image.load('img/xdr.bmp')
        self.image = pygame.sprite.Sprite()
        self.rect = self.image.get_rect()
        self.screen_rect = screen_game.get_rect()
        
        # Каждый новый шар появляется в верхнем левом углу
        self.rect.x = self.rect.left + 45
        self.rect.y = self.screen_rect.centery - 20
        # Сохранение точной позиции шара.
        self.x = float(self.rect.x)
        
    def blitme(self):
        """Выводит шар в текущем положении."""
        self.screen.blit(self.image, self.rect)
        
    def update(self):
        """Движение шара."""
        self.x += (self.ai_set.boll_speed * self.ai_set.fleet_direction)
        self.rect.x = self.x
        
    def check_edg(self):
        """Проверка достижения шара планки."""
        self.screen_rect = screen_game.get_rect()
        if self.rect_1.right >= rect_1.right:
            return True
        elif self.rect_2.left <= rect_2.left:
            return True

 setting.py
class Settings():
    """Класс для хранения настроек игры."""    
    def __init__(self):
        """Инициализирует настройки игры."""
        # Параметры экрана.
        self.screen_width = 1000
        self.screen_height = 600
        self.bg_color = (0, 150, 150)
        
        # Настройка планок
        self.rect_speed_factor = 10
        self.rect_distance = 30
        
        # Скорость шара
        self.boll_speed = 1
        # fleet_direction = 1 означает движение в право; а -1 в лево;
        self.fleet_direction = 1

 rectangle.py
#! /usr/bin/env python3
# coding: utf8
import pygame
class rectan_gle():
    def __init__(self, ai_set, screen_game):
        # Инициализирует рисунок на экране и задает его начальную позицию
        self.screen_game = screen_game
        self.ai_set = ai_set
        
    
        # Загрузка изображения и инициализация прямоугольника
        self.image_1 = pygame.image.load('img/gg.bmp')
        self.image_2 = self.image_1
        self.rect_1 = self.image_1.get_rect()
        self.rect_2 = self.image_2.get_rect()
        self.screen_rect = screen_game.get_rect()
        
        # Каждая новя планка появляется с боку экрана на расстоянии от края.
        self.rect_1.centery = self.screen_rect.centery
        self.rect_1.left = self.screen_rect.left + self.ai_set.rect_distance
        self.rect_2.centery = self.screen_rect.centery
        self.rect_2.right = self.screen_rect.right - self.ai_set.rect_distance
        
        # Флаг перемещения
        self.moving_down = 0    # 0 = False
        self.moving_up = 0
        
    def update(self):
        """Обновляет позицию планки с учетом флага."""
        if self.moving_down and self.rect_1.bottom < self.screen_rect.bottom:
            self.rect_1.centery += self.ai_set.rect_speed_factor
            self.rect_2.centery += self.ai_set.rect_speed_factor
        if self.moving_up and self.rect_1.top > 0:
            self.rect_1.centery -= self.ai_set.rect_speed_factor
            self.rect_2.centery -= self.ai_set.rect_speed_factor
        
    def blitme(self):
        """Рисует планку в текущей позиции"""
        self.screen_game.blit(self.image_1, self.rect_1)
        self.screen_game.blit(self.image_2, self.rect_2)

 func_game.py
# /usr/bin/env python3
# coding: utf8
import pygame, sys
def check_event(rect_gl):
    """Обрабатывает нажатия клавиш и события мыши."""
    for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            
            # Перемещение планки.
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_q:
                    sys.exit()
                if event.key == pygame.K_DOWN:
                    rect_gl.moving_down = 1     # 1 = True
                if event.key == pygame.K_UP:
                    rect_gl.moving_up = 1
            elif event.type == pygame.KEYUP:
                if event.key == pygame.K_DOWN:
                    rect_gl.moving_down = 0     # 0 = False
                if event.key == pygame.K_UP:
                    rect_gl.moving_up = 0
def check_boll_edg(ai_set, boll_b):
    """Реагирует на достижение шаром планки."""
    for boll in boll_b.sprite():
        if boll.check_edg():
            chenge_fleet_direction(ai_set, boll_b)
            break
        ai_set.fleet_direction *= -1
def update_boll(ai_set, boll_b):
    """ 
    Проверяет, достиг ли шар планки,
     после чего обновляет позицию шара 
     """
    check_boll_edg(ai_set, boll_b)
    boll_b.update

 Game.py
#! /usr/bin/env python3
# coding: utf8
import pygame
import func_game as kt
from setting import Settings
from rectangle import rectan_gle
from boll import Booll
def rungame():
    # Инициализирует игру и создает объект экрана
    pygame.init()
    ai_set = Settings()    
    screen_game = pygame.display.set_mode(
                    (ai_set.screen_width, ai_set.screen_height))
    pygame.display.set_caption("Tennis")
    
    # Создание планки.
    rect_gl = rectan_gle(ai_set, screen_game)
    boll_b = Booll(ai_set, screen_game,)
    """Основной цикл игры"""
    while 1:
        # Обработка нажатия клавиш
        kt.check_event(rect_gl)
        
        # Обновление положения мяча.
        kt.update_boll(ai_set, boll_b)
        
        # При каждом проходе цикла перерисовывается экран
        screen_game.fill(ai_set.bg_color)
        rect_gl.update()
        rect_gl.blitme()
        boll_b.blitme()
                
        # Отображение последнего прорисованного экрана
        pygame.display.flip()
rungame()

       # Загрузка изображения шара.
        self.image = pygame.image.load('img/xdr.bmp')
        self.image = pygame.sprite.Sprite()

 class Block(pygame.sprite.Sprite):
    # Constructor. Pass in the color of the block,
    # and its x and y position
    def __init__(self, color, width, height):
       # Call the parent class (Sprite) constructor
       pygame.sprite.Sprite.__init__(self)
       # Create an image of the block, and fill it with a color.
       # This could also be an image loaded from the disk.
       ''' Если я чтото понимаю в програмировании, то как раз две следующие строчки  
          нужно заменить на ваше self.image = pygame.image.load('img/xdr.bmp')
          а вот self.image = pygame.sprite.Sprite() там явно лишнее.
       '''
       self.image = pygame.Surface([width, height])
       self.image.fill(color)
       # Fetch the rectangle object that has the dimensions of the image
       # Update the position of this object by setting the values of rect.x and rect.y
       '''
          А вот тут уже получаем наш get_rect()
       '''
       self.rect = self.image.get_rect()