Hallo, ich mache ein Spiel in pygame und frage mich, wie und was der beste Weg ist, ein Spiel über dem Bildschirm hinzuzufügen. Hier ist der Code, bis zu dem die Gesundheit des Spielers kleiner oder gleich 0 ist:

import pygame
import random
import pygame.mixer
import Funk
from player import *
from zombie import *
from level import *
from bullet import *
from constants import *
from time import *
import menu as dm

class Game():

    def __init__(self):
        pygame.init()
        pygame.mixer.init()

        #pygame.mixer.music.load('sounds/menugame.ogg')
        #pygame.mixer.music.play(-1)

        # A few variables
        self.gravity = .50
        self.ground = pygame.Rect(0, 640, 1280, 80)
        self.red = (255, 0, 0)
        self.darkred = (200, 0, 0)
        self.darkblue = (0, 0, 200)
        self.darkgreen = (0, 200, 0)
        self.clock = pygame.time.Clock() #to track FPS
        self.fps = 0

        # Bullets
        self.bullets = []

        # Screen
        size = (1280, 720)
        self.screen = pygame.display.set_mode(size)
        pygame.display.set_caption("Moon Survival")
        self.clock.tick(self.fps)

        # Moon / Background
        self.moon = Background()

        # Zombies
        self.zombies = []
        for i in range(10):
            self.zombies.append( Zombie(random.randint(0,1280), random.randint(0,720)) )

        # Player
        self.player = Player(25, 320, self.gravity)

        # Font for text
        self.font = pygame.font.SysFont(None, 72)

        # Pause - center on screen
        self.pause_text = self.font.render("PAUSE", -1, (255,0,0))
        self.pause_rect = self.pause_text.get_rect(center = self.screen.get_rect().center)

    def run(self):

        clock = pygame.time.Clock()

        # "state machine" 
        RUNNING   = True
        PAUSED    = False 
        GAME_OVER = False

        # Game loop
        while RUNNING:

            # (all) Events

            for event in pygame.event.get():

                if event.type == pygame.QUIT:
                    RUNNING = False

                elif event.type == pygame.KEYDOWN:

                    if event.key == pygame.K_s:
                        self.bullets.append(Bullet(self.player.rect.x + 30, self.player.rect.y + 30, self.player.direction))

                    if event.key == pygame.K_ESCAPE:
                        RUNNING = False

                    elif event.key == pygame.K_p:
                        choose = dm.dumbmenu(self.screen, [
                        'Resume Game',

                        'Menu',

                        'Quit Game'], 200, 200,'orecrusherexpanded',100,0.75,self.darkred,self.red)

                        if choose == 0:
                            print "You choose 'Start Game'."
                            break
                        elif choose == 1:
                            execfile('run_game.py')
                            print "You choose 'Controls'."
                        if choose == 2:
                            print "You choose 'Quit Game'."
                            pygame.quit()
                            sys.exit()

                # Player/Zomies events  

                if not PAUSED and not GAME_OVER:
                    self.player.handle_events(event)

            # (all) Movements / Updates

            if not PAUSED and not GAME_OVER:
                self.player_move()
                self.player.update()

                for z in self.zombies:
                    self.zombie_move(z)
                    z.update(self.screen.get_rect())

                for b in self.bullets:
                    b.update()
                    for tile in self.moon.get_surrounding_blocks(b):
                        if tile is not None:
                            if pygame.sprite.collide_rect(b, tile):
                                # Destroy block
                                x = tile.rect.x / tile.rect.width
                                y = tile.rect.y / tile.rect.height
                                self.moon.levelStructure[x][y] = None
                                try:
                                    self.bullets.remove(b)
                                except:
                                    continue

            # (all) Display updating

            self.moon.render(self.screen)

            for z in self.zombies:
                z.render(self.screen)

            for b in self.bullets:
                b.render(self.screen)

            self.player.render(self.screen)

            if PAUSED:
                self.screen.blit(self.pause_text, self.pause_rect)

            Funk.text_to_screen(self.screen, 'Level 1', 5, 675)
            Funk.text_to_screen(self.screen, 'Health: {0}'.format(self.player.health), 5, 0)
            Funk.text_to_screen(self.screen, 'Score: {0}'.format(self.player.score), 400, 0)
            Funk.text_to_screen(self.screen, 'Time: {0}'.format(self.player.alivetime), 750, 0)

            pygame.display.update()

            # FTP

            clock.tick(100)

        # --- the end ---
        pygame.quit()

    def player_move(self):
        # add gravity
        self.player.do_jump()

        # simulate gravity
        self.player.on_ground = False
        if not self.player.on_ground and not self.player.jumping:
            self.player.velY = 4

        # Health
        for zombie in self.zombies:
            if pygame.sprite.collide_rect(self.player, zombie):
                self.player.health -= 5
                if self.player.health <= 0:


        # move player and check for collision at the same time
        self.player.rect.x += self.player.velX
        self.check_collision(self.player, self.player.velX, 0)
        self.player.rect.y += self.player.velY
        self.check_collision(self.player, 0, self.player.velY)

    def zombie_move(self, zombie_sprite):
        # add gravity
        zombie_sprite.do_jump()

        # simualte gravity
        zombie_sprite.on_ground = False
        if not zombie_sprite.on_ground and not zombie_sprite.jumping:
            zombie_sprite.velY = 4

        # Zombie damage
        for zombie in self.zombies:
            for b in self.bullets:
                if pygame.sprite.collide_rect(b, zombie):
                    #The same bullet cannot be used to kill
                    #multiple zombies and as the bullet was 
                    #no longer in Bullet.List error was raised
                    zombie.health -= 10                
                    self.bullets.remove(b)
                    if zombie.health <= 0:
                        self.player.score += random.randint(10, 20)
                        self.zombies.remove(zombie)
                    break

        # move zombie and check for collision
        zombie_sprite.rect.x += zombie_sprite.velX
        self.check_collision(zombie_sprite, zombie_sprite.velX, 0)
        zombie_sprite.rect.y += zombie_sprite.velY
        self.check_collision(zombie_sprite, 0, zombie_sprite.velY)

    def check_collision(self, sprite, x_vel, y_vel):
        # for every tile in Background.levelStructure, check for collision
        for block in self.moon.get_surrounding_blocks(sprite):
            if block is not None:
                if pygame.sprite.collide_rect(sprite, block):
                    # we've collided! now we must move the collided sprite a step back
                    if x_vel < 0:
                        sprite.rect.x = block.rect.x + block.rect.w

                        if sprite is Zombie:
                            print "wohoo"

                    if type(sprite) is Zombie:
                            # the sprite is a zombie, let's make it jump
                            if not sprite.jumping:
                                sprite.jumping = True
                                sprite.on_ground = False

                    if x_vel > 0:
                        sprite.rect.x = block.rect.x - sprite.rect.w

                    if y_vel < 0:
                        sprite.rect.y = block.rect.y + block.rect.h

                    if y_vel > 0 and not sprite.on_ground:
                        sprite.on_ground = True
                        sprite.rect.y = block.rect.y - sprite.rect.h

#---------------------------------------------------------------------

Game().run()

Ich bin mir nicht ganz sicher, wie ich es machen soll, weil ich versucht habe, ein anderes Py-Call-Spiel zu verwenden, aber die Zeit, in der der Spieler gestorben ist, wurde dann auf 0 zurückgesetzt und wieder erhöht, sodass alles passieren kann, wo der Spieler stirbt ?

0
GhostFrag1 6 Dez. 2013 im 22:56

3 Antworten

Beste Antwort

Verwenden Sie Zustände in Ihrem Motor.

Ein Pseudocode:

while game_running:
    if STATE == STATE_MENU:
        Menu_ProcessInput()
        Menu_Update()
        Menu_Draw()
    elif STATE == STATE_INGAME:
        INGAME_ProcessInput()
        INGAME_Update()
        INGAME_Draw()
    elif STATE == STATE_GAMEOVER:
        GAMEOVER_ProcessInput()
        GAMEOVER_Update()
        GAMEOVER_Draw()

Dies ist eine einfache Lösung, bei der nicht mit mehreren Schleifen für Menüs usw. herumgespielt werden muss.

2
Marcus Møller 6 Dez. 2013 im 21:09

Sie sollten Zustände verwenden, wie Marcus schrieb. Ich werde darauf etwas näher eingehen. Sie sollten eine Klasse haben, die Ihre Spielklasse sein wird.

Dies schließt alle Bildschirme ein. Ein Entwurf würde so aussehen:

class GameEngine:
    def __init__(self):
        #initialize pygame
        #load resources
        #etc...
        states = [PlayGameState(),OptionsState(),GameOverState()]
    def run(self):
        while(True):
            states[current_state].draw()
            states[current_state].update()
            for event in pygame.event.get():
                states[current_state].input(event)

Dann können Sie die Logik für alle Zustände trennen, und das Hinzufügen eines neuen Bildschirms ist nur eine Frage des Hinzufügens zur Zustandsliste.

Das Anhalten des Spiels in diesem Beispiel wäre wirklich einfach. Es würde einfach sehen, ob der event_key ESC und der Status PlayGame war. Es würde ihn in PauseState ändern.

Die GameEngine könnte auch den Status abfragen, um festzustellen, ob er beendet wurde, sodass Sie zum GameOverState und danach zurück zum MainState wechseln können.

2
Bartlomiej Lewandowski 6 Dez. 2013 im 21:56

Lösen Sie eine Ausnahme aus und fangen Sie sie an einem Punkt ab, an dem Sie sich außerhalb des Spielverlaufs befinden, aber mit den Daten, die Sie für die Bearbeitung eines Spiels benötigen.

try:
    stuff()
except GameOver:
    game_over_screen()
-2
leewz 6 Dez. 2013 im 19:19