Das deutsche Python-Forum

Code: Alles auswählen

import pygame
from pygame.sprite import Group
from settings import Settings
import game_functions as gf



def run_game():

    pygame.init()
    ai_settings = Settings()
    screen = pygame.display.set_mode((ai_settings.screen_width,
        ai_settings.screen_height))
    pygame.display.set_caption("Star")

    stars = Group()

    gf.create_grid(ai_settings, screen, stars)

    while True:
        gf.check_event()
        gf.update_screen(ai_settings, screen, stars)

run_game()
/code]

Dass Bild mit dem stern.

[code]import pygame
from pygame.sprite import Sprite

class Star(Sprite):
    """Create a star"""
    def __init__(self, ai_settings, screen):
        super(Star, self).__init__()
        self.screen = screen
        self.ai_settings = ai_settings

        self.image = pygame.image.load('images/star.bmp')
        self.rect = self.image.get_rect()

        
        self.rect.x = self.rect.width
        self.rect.y = self.rect.height

        self.x = float(self.rect.x)

            

    def blitme(self):
        """Show the star on the screen."""
        self.screen.blit(self.image, self.rect)
/code]

[code]import sys

Die game_fucntion

import pygame
from stars import Star

def check_event():
    """A function to respond end the game."""
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()

def update_screen(ai_settings, screen, stars):
    """A function to update the screen."""
    screen.fill(ai_settings.bg_color)
    stars.draw(screen)
    pygame.display.flip()


def get_number_stars(ai_settings, star_width):
    """Determine the number of the stars."""
    avaible_space_x = ai_settings.screen_width - 2 * star_width
    star_number_x = avaible_space_x // (2 * star_width)
    return star_number_x


def get_number_rows(ai_settings, star_height):
    """Determine the number of rows of aliens that fit on the screen."""
    avaible_space_y = ai_settings.screen_height + star_height
    number_rows_y = avaible_space_y // (2 * star_height)
    return number_rows_y

def create_star(ai_settings, screen, stars, star_number, row_number):
    """Create a star and set it to the place."""
    star = Star(ai_settings, screen)
    star_width = star.rect.width
    star.x = star_width + 2 * star_width * star_number
    star.rect.x = star.x
    star.rect.y = star.rect.height + 2 * star.rect.height * row_number
    stars.add(star)

def create_grid(ai_settings, screen, stars):
    """Create a rid of the stars."""
    star = Star(ai_settings, screen)
    star_number_x = get_number_stars(ai_settings, star.rect.width)
    number_rows_y = get_number_rows(ai_settings, star.rect.height)

    for star_number in range(star_number_x):
        for row_number in range(number_rows_y):
            create_star(ai_settings, screen, stars, star_number, row_number)
                        
/code]

Die settings 
[code]import pygame

class Settings():

    def __init__(self):
        """Initaliz the games settings."""
        self.screen_width = 1200
        self.screen_height = 800
        self.bg_color = (230, 230, 230)
        
/code]

Code: Alles auswählen

#!/usr/bin/env python3
import pygame
from pygame.sprite import Group, Sprite

SCREEN_WIDTH = 1200
SCREEN_HEIGHT = 800
BACKGROUND_COLOR = (230, 230, 230)
STAR_IMAGE_FILENAME = "images/star.bmp"


class Star(Sprite):
    def __init__(self, *groups):
        Sprite.__init__(self, *groups)
        #
        # TODO Seems to be a bit wasteful to load that image for each identical
        #   looking star.
        #
        self.image = pygame.image.load(STAR_IMAGE_FILENAME)
        self.rect = self.image.get_rect()


def process_events():
    """
    Process PyGame events.
    
    Returns `False` if the program should stop, `True` otherwise.
    """
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            return False
    return True


def update_screen(screen, stars):
    screen.fill(BACKGROUND_COLOR)
    stars.draw(screen)
    pygame.display.flip()


def get_stars_per_row(star_width):
    """
    Calculates the number of stars per row with one star width space between
    each star.
    """
    return (SCREEN_WIDTH - star_width) // (2 * star_width)


def get_number_of_rows(star_height):
    """
    Calculates the number of rows of stars with one star height space between
    the rows.
    """
    return (SCREEN_HEIGHT - star_height) // (2 * star_height)


def create_star(stars, star_number, row_number):
    """
    Creates a star, adds it to the `stars` group, and positions it on the grid.
    """
    star_rect = Star(stars).rect
    star_rect.x = star_rect.width + 2 * star_rect.width * star_number
    star_rect.y = star_rect.height + 2 * star_rect.height * row_number


def create_grid(stars):
    """
    Creates a grid of stars and adds them to the given `stars` group.
    """
    star_rect = Star().rect
    for star_number in range(get_stars_per_row(star_rect.width)):
        for row_number in range(get_number_of_rows(star_rect.height)):
            create_star(stars, star_number, row_number)


def main():
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Star")

    stars = Group()
    create_grid(stars)
    #
    # FIXME Burns a lot CPU time for static content.  Introduce a `pygame.Clock`
    #   to keep this loop sane.
    #
    while process_events():
        update_screen(screen, stars)

    pygame.quit()


if __name__ == "__main__":
    main()