Pygame

[LoveMCU]

Hi.
Ich möchte Break out in Python programmieren. Bis jetzt ist auch alles gut. Allerdings brauch ich jetzt viele Blöcke statt ein.

Code: Alles auswählen

import pygame, sys, random
pygame.init()

class player:
	def __init__(self, player_posX, player_posY, player_width, player_height):
		self.player_posX = player_posX
		self.player_posY = player_posY
		self.player_width = player_width
		self.player_height = player_height 
		self.player_speed = 3

class ball:
	def __init__(self, ball_posX, ball_posY, ball_width, ball_height):
		self.ball_posX = ball_posX
		self.ball_posY = ball_posY
		self.ball_width = ball_width
		self.ball_height = ball_height
		self.ran_choice = (2, -2)
		self.ball_speedX = random.choice(self.ran_choice)
		self.ball_speedY = 1

class block:
	def __init__(self, block_posX, block_posY, block_width, block_height, lives):
		self.block_posX = block_posX
		self.block_posY = block_posY
		self.block_width = block_width
		self.block_height = block_height
		self.lives = lives

def exit():
	for event in pygame.event.get():
		if event.type == pygame.QUIT:
			pygame.quit
			sys.exit()

def draw():
	global plank, player_rect, bg, ball_sprite, ball_rect, block_rect, block_1
	screen.blit(bg, (0,0))
	pygame.draw.rect(screen, white, player_rect)
	pygame.draw.ellipse(screen, white, ball_rect)
	if block_1.lives > 0:
		if block_1.lives == 1:
			pygame.draw.rect(screen, red, block_rect)
		if block_1.lives == 2:
			pygame.draw.rect(screen, blue, block_rect)
		if block_1.lives == 3:
			pygame.draw.rect(screen, green, block_rect)

def player_mov():
	global player_rect, ball, ball_rect, player, screenwidth,start, ball_rect
	keys = pygame.key.get_pressed()
	if keys[pygame.K_a] and player_rect.left >= 0:
		player_rect.left -= player.player_speed
		if start == False:
			ball_rect.left -= player.player_speed
	if keys[pygame.K_d] and player_rect.right <= screenwidth:
		player_rect.right += player.player_speed
		if start == False:
			ball_rect.right += player.player_speed

def ball_mov():
	global ball, ball_rect, run, start
	if run and start:
		ball_rect.x -= ball.ball_speedX
		ball_rect.y -= ball.ball_speedY

def bounce_borders():
	global ball, ball_rect, run, screenheight
	if run and start:
		if ball_rect.top <= 0:
			ball.ball_speedY = -ball.ball_speedY
		if ball_rect.right >= screenwidth or ball_rect.left <= 0:
			ball.ball_speedX = -ball.ball_speedX
		if ball_rect.bottom >= screenheight:
			run = False

def player_col():
	global ball_rect, player_rect, ball, player
	if ball_rect.colliderect(player_rect):
		if abs(ball_rect.bottom - player_rect.top) <= 5:
			ball.ball_speedY *= -1
		if abs(ball_rect.left - player_rect.right) <= 5 and player.player_speed > 0:
			ball.ball_speedX *= -1
		if abs(ball_rect.right - player_rect.left) <= 5  and player.player_speed > 0:
			ball.ball_speedX *= -1

def game_start():
	global start, ball_rect
	keys = pygame.key.get_pressed()
	if keys[pygame.K_SPACE] and start == False:
		start = True

def block_coll():
	global ball_rect, block_rect, ball, block_1
	if ball_rect.colliderect(block_rect) and block_1.lives > 0:
		if abs(ball_rect.bottom - block_rect.top) <= 5:
			ball.ball_speedY *= -1
			block_1.lives = block_1.lives -1
		if abs(ball_rect.top - block_rect.bottom) <= 5:
			ball.ball_speedY *= -1
			block_1.lives = block_1.lives -1
		if abs(ball_rect.left - block_rect.right) <= 5:
			ball.ball_speedX *= -1
			block_1.lives = block_1.lives -1
		if abs(ball_rect.right - block_rect.left) <= 5:
			ball.ball_speedX *= -1
			block_1.lives = block_1.lives -1

# screen and clock
screenheight = 600 
screenwidth = 800
FPS = 244
screen = pygame.display.set_mode((screenwidth,screenheight))
clock = pygame.time.Clock()

# colors
red = (255,0,0)
blue = (0,0,255)
green = (0,255,0)
white = (255,255,255)

# player
player = player(350,screenheight-50, 130, 15)
player_rect = pygame.Rect(player.player_posX, player.player_posY, player.player_width, player.player_height )

# back ground
bg = pygame.image.load("Bg.png").convert()

# ball
ball = ball(player.player_posX + 50, player.player_posY - 30, 30, 30)
ball_rect = pygame.Rect(ball.ball_posX, ball.ball_posY, ball.ball_width, ball.ball_height)

# block
block_1 = block(80, 35, 100, 20, 3)
block_rect = pygame.Rect(block_1.block_posX, block_1.block_posY, block_1.block_width, block_1.block_height)	

# main loop
start = False
run = True
while run:
	# exit
	exit()

	# draw
	draw()

	# player movement
	player_mov()

	# ball movement
	ball_mov()

	# bounce on borders
	bounce_borders()

	# start
	game_start()

	# block collison
	block_coll()

	# collision with player
	player_col()

	clock.tick(FPS)
	pygame.display.update()

Wie kann ich jetzt mehrere Blöcke erstellen? Danke im voraus

[LoveMCU]

Multiple Gegenstände in pygame erzeugen

[__deets__]

Wenn man viele Dinge von etwas will, nimmt man passende Datenstrukturen. In diesem Fall eine Liste.

[Sirius3]

Klassen schreibt man großen Anfangsbuchstaben, Eingerückt wird mit 4 Leerzeichen pro Ebene, keine Tabs.
pygame.quit sollte man auch aufrufen, und sys.exit darf nicht in einer so tief verschachtelten Funktion vorkommen. Dafür wäre ja die Variable `run` da, die im Moment noch gar nicht benutzt wird.
Globale Variablen darf man nicht benutzen, alles was eine Funktion braucht sollte sie auch über ihre Argumente bekommen.
Alles auf oberster Ebene sollte auch in eine Funktion wandern, die man üblicherweise `main` nennt, dann erledigt sich das mit den globalen Variablen von ganz alleine.

[__blackjack__]

Namen sollten keine kryptischen Abkürzungen enthalten. Alleine in der Hauptschleife am Ende könnte man sich die ganzen Kommentare sparen wenn man die Funktionen verständlich benennen würde.