[PyGame] Can't figure out my problem...

Darkseige · (This post was last modified: May-19-2019, 03:01 PM by Yoriz.)

Hi, so im new to this forum as well as python and I decided to create a little game to learn the language a couple of days ago (The game being a cube that dodges other cubes and get score when the other cubes reach bottom of screen. The speed increases at the same time as the score).

The game works just fine and I am looking to improve it. The first improve I am working on is a title screen with buttons. The title screen seems to work (at least I think the problem isn't there), but my game lacks a bunch of features it had before i decided to add the title screen Undecided

. Some examples of functionalities that doesn't appear in the "new" game are:

1. The speed doesn't increase anymore even if the score increases (stays stuck on its base value without changing like the code tells it to do).

2. I drew a line in the middle of the screen and if the player goes higher than that line, he is supposed to earn double the score (he doesn't in the "new" game).

My guess is that the problem must be into my bad use of functions though I have no idea where i messed up Wall

. If someone could replie to identifie my mistake it would be really appreciated! Big Grin

The next two sections will contain the code of the game alone and the one with the title screen respectively.

import pygame
import sys
import random



pygame.init()

HEIGHT = 600
WIDTH = 800

GREEN = (0,255,0)
BLACK = (0,0,0)
RED = (255,0,0)
YELLOW = (255,255,0)
WHITE = (255,255,255)
BLUE = (0,0,255)


middle_line_pos = [0, HEIGHT/2]


player_size = 46
player_pos = [WIDTH/2-player_size/2, HEIGHT-2*player_size]
player_x = player_pos[0]
player_y = player_pos[1]

enemy_size = 46
enemy_pos = [random.randint(0, WIDTH-enemy_size), 0]
enemy_list = [enemy_pos]

SPEED = 10

screen = pygame.display.set_mode((WIDTH, HEIGHT))



game_over = False

SCORE = 0

clock = pygame.time.Clock()

myFont = pygame.font.SysFont("monospace", 35)


def set_level(SCORE, SPEED):

	SPEED = SCORE/15 + 5

	return SPEED


def drop_enemies(enemy_list):
	delay = random.random()
	if len(enemy_list) < 10 and delay < 0.1:
		x_pos = random.randint(0, WIDTH-enemy_size)
		y_pos = 0
		enemy_list.append([x_pos, y_pos])


def draw_enemies(enemy_list):
	for enemy_pos in enemy_list:
		pygame.draw.rect(screen, BLACK, (enemy_pos[0]-2, enemy_pos[1]-2, 50, 50))
		pygame.draw.rect(screen, RED, (enemy_pos[0], enemy_pos[1], enemy_size, enemy_size))


def update_enemy_positions(enemy_list, SCORE):
	for idx, enemy_pos in enumerate(enemy_list):
		if enemy_pos[1] >= 0 and enemy_pos[1] < HEIGHT:
			enemy_pos[1] += SPEED
		else:
			if player_pos[1] < HEIGHT/2:
				enemy_list.pop(idx)
				SCORE += 2

			else:
				enemy_list.pop(idx)
				SCORE += 1
	return SCORE

def collision_check(enemy_list, player_pos):
	for enemy_pos in enemy_list:
		if detect_collision(enemy_pos, player_pos):
			return True
	return False


def detect_collision(player_pos, enemy_pos):

	p_x = player_pos[0]
	p_y = player_pos[1]
	e_x = enemy_pos[0]
	e_y = enemy_pos[1]

	if ((e_x >= p_x and e_x <= (p_x + player_size)) or (p_x >= e_x and p_x <= (e_x + enemy_size))):
		if (e_y >= p_y and e_y <= (p_y + player_size) or (p_y >= e_y and p_y <= (e_y + enemy_size))):
			return True
	return False




while not game_over:

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

		if event.type == pygame.KEYDOWN:

			x = player_pos[0]
			y = player_pos[1]

			if event.key == pygame.K_LEFT:
				x -= player_size

			elif event.key == pygame.K_RIGHT:
				x += player_size

			elif event.key == pygame.K_UP:
				y -= player_size

			elif event.key == pygame.K_DOWN:
				y += player_size

			player_pos = [x, y]


	screen.fill(WHITE)

	#if enemy_pos[1] >= 0 and enemy_pos[1] < HEIGHT:
		#enemy_pos[1] += SPEED
	#else:
		#enemy_pos[0] = random.randint(0, WIDTH-enemy_size)
		#enemy_pos[1] = 1

	

	if detect_collision(player_pos, enemy_pos):
		game_over = True

	elif (player_pos[0] < 0) or (player_pos[0] > WIDTH-player_size) or (player_pos[1] < 0) or (player_pos[1] > HEIGHT-player_size):
		game_over = True
	

	drop_enemies(enemy_list)

	SCORE = update_enemy_positions(enemy_list, SCORE)
	SPEED = set_level(SCORE, SPEED)


	text = "Score:" + " " + str(SCORE)
	label = myFont.render(text, 1, BLACK)
	screen.blit(label, (WIDTH-200, HEIGHT-40))


	if collision_check(enemy_list, player_pos):
		game_over = True

	draw_enemies(enemy_list)

	pygame.draw.rect(screen, BLACK, (player_pos[0]-2, player_pos[1]-2, 50, 50))
	pygame.draw.rect(screen, GREEN, (player_pos[0], player_pos[1], player_size, player_size))
	pygame.draw.rect(screen, BLUE, (middle_line_pos[0], middle_line_pos[1], WIDTH, 2))

	clock.tick(30)

	pygame.display.update()

if game_over:
 	print("Game Over!")
 	print("You're score is" + " " + str(SCORE))	
 	print("Try again!")
else:
 	pass

import pygame
import time
import random
import sys
 
pygame.init()
 
intro = True

WIDTH = 800
HEIGHT = 600
 
BLACK = (0,0,0)
WHITE = (255,255,255)
RED_B = (255,0,0)
GREEN_B = (0,255,0)
YELLOW = (255,255,0)
BLUE_B = (0,0,255)
RED = (200,0,0)
BLUE = (0,0,200)
GREEN = (0,200,0)


middle_line_pos = [0, HEIGHT/2]

player_size = 46
player_pos = [WIDTH/2-player_size/2, HEIGHT-2*player_size]
player_x = player_pos[0]
player_y = player_pos[1]

enemy_size = 46
enemy_pos = [random.randint(0, WIDTH-enemy_size), 0]
enemy_list = [enemy_pos]


game_over = False

SCORE = 0
SPEED = 10

myFont = pygame.font.SysFont("monospace", 35)

 
gameDisplay = pygame.display.set_mode((WIDTH,HEIGHT))
pygame.display.set_caption('Dodge the Blocks')
clock = pygame.time.Clock()

 

def set_level(SCORE, SPEED):

    SPEED = SCORE/15 + 5

    return SPEED


def drop_enemies(enemy_list):
    delay = random.random()
    if len(enemy_list) < 10 and delay < 0.1:
        x_pos = random.randint(0, WIDTH-enemy_size)
        y_pos = 0
        enemy_list.append([x_pos, y_pos])


def draw_enemies(enemy_list):
    for enemy_pos in enemy_list:
        pygame.draw.rect(gameDisplay, BLACK, (enemy_pos[0]-2, enemy_pos[1]-2, 50, 50))
        pygame.draw.rect(gameDisplay, RED, (enemy_pos[0], enemy_pos[1], enemy_size, enemy_size))


def update_enemy_positions(enemy_list, SCORE):
    for idx, enemy_pos in enumerate(enemy_list):
        if enemy_pos[1] >= 0 and enemy_pos[1] < HEIGHT:
            enemy_pos[1] += SPEED
        else:
            if player_pos[1] < HEIGHT/2:
                enemy_list.pop(idx)
                SCORE += 2

            else:
                enemy_list.pop(idx)
                SCORE += 1
    return SCORE

def detect_collision(player_pos, enemy_pos):

    p_x = player_pos[0]
    p_y = player_pos[1]
    e_x = enemy_pos[0]
    e_y = enemy_pos[1]

    if ((e_x >= p_x and e_x <= (p_x + player_size)) or (p_x >= e_x and p_x <= (e_x + enemy_size))):
        if (e_y >= p_y and e_y <= (p_y + player_size) or (p_y >= e_y and p_y <= (e_y + enemy_size))):
            return True
    return False



def collision_check(enemy_list, player_pos):
    for enemy_pos in enemy_list:
        if detect_collision(enemy_pos, player_pos):
            return True
    return False



def text_objects(text, font):
    textSurface = font.render(text, True, BLACK)
    return textSurface, textSurface.get_rect()
 
def message_display(text):
    largeText = pygame.font.Font('freesansbold.ttf',75)
    TextSurf, TextRect = text_objects(text, largeText)
    TextRect.center = ((HEIGHT/2),(WIDTH/2))
    gameDisplay.blit(TextSurf, TextRect)
 
    pygame.display.update()
 
    time.sleep(2)
 
    pygame.quit()
    quit()
    




def button(msg,x,y,w,h,ic,ac,action=None):
    
    mouse = pygame.mouse.get_pos()

    click = pygame.mouse.get_pressed()
    print(click)

    if x+w > mouse[0] > x and y+h > mouse[1] > y:
        pygame.draw.rect(gameDisplay, ac,(x,y,w,h))
        if click[0] == 1 and action != None:

            if action == "play":
                game_loop()
            elif action == "quit":
                pygame.quit()
                quit()

 





def game_intro():

    intro = True

    while intro:
        for event in pygame.event.get():
            #print(event)
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
                
        gameDisplay.fill(BLUE)
        largeText = pygame.font.Font('freesansbold.ttf',75)
        TextSurf, TextRect = text_objects("Dodge the Blocks", largeText)
        TextRect.center = ((WIDTH/2),(HEIGHT/4))
        gameDisplay.blit(TextSurf, TextRect)

        mouse = pygame.mouse.get_pos()
        if 150+150 > mouse[0] > 125 and 350+50 > mouse[1] > 350:
            pygame.draw.rect(gameDisplay, GREEN_B,(125,350,150,50))
        else:
             pygame.draw.rect(gameDisplay, GREEN,(125,350,150,50))
        if 150+525 > mouse[0] > 525 and 350+50 > mouse[1] > 350:
            pygame.draw.rect(gameDisplay, RED_B,(525,350,150,50))
        else:
            pygame.draw.rect(gameDisplay, RED,(525,350,150,50))

        button("Singleplayer", 125, 350, 150, 50, GREEN, GREEN_B, "play")
        button("Multiplayer", 525, 350, 150, 50, RED, RED_B, "quit")

        smallText = pygame.font.Font("freesansbold.ttf",20)
        textSurf, textRect = text_objects("Singleplayer", smallText)
        textRect.center = ( (150+(100/2)), (350+(50/2)) )
        gameDisplay.blit(textSurf, textRect)

        smallText = pygame.font.Font("freesansbold.ttf",20)
        textSurf, textRect = text_objects("Multiplayer", smallText)
        textRect.center = ( (75+(525)), (350+(50/2)) )
        gameDisplay.blit(textSurf, textRect)


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

    ########################################################################

        #if game_over:
        #print("Game Over!")
        #print("You're score is" + " " + str(SCORE)) 
       # print("Try again!")
   #else:
        #pass

def game_loop():

    game = True

    middle_line_pos = [0, HEIGHT/2]

    player_size = 46
    player_pos = [WIDTH/2-player_size/2, HEIGHT-2*player_size]
    player_x = player_pos[0]
    player_y = player_pos[1]

    enemy_size = 46
    enemy_pos = [random.randint(0, WIDTH-enemy_size), 0]
    enemy_list = [enemy_pos]
    
    SPEED = 10

    SCORE = 0

    while game:


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

            if event.type == pygame.KEYDOWN:

                x = player_pos[0]
                y = player_pos[1]  

                if event.key == pygame.K_LEFT:
                    x -= player_size

                elif event.key == pygame.K_RIGHT:
                    x += player_size

                elif event.key == pygame.K_UP:
                    y -= player_size

                elif event.key == pygame.K_DOWN:
                    y += player_size

                player_pos = [x, y]


        gameDisplay.fill(WHITE)

        #if enemy_pos[1] >= 0 and enemy_pos[1] < HEIGHT:
            #enemy_pos[1] += SPEED
        #else:
            #enemy_pos[0] = random.randint(0, WIDTH-enemy_size)
            #enemy_pos[1] = 1

        

        if detect_collision(player_pos, enemy_pos):

            message_display('Game Over!')

        elif (player_pos[0] < 0) or (player_pos[0] > WIDTH-player_size) or (player_pos[1] < 0) or (player_pos[1] > HEIGHT-player_size):

            message_display('Game Over!')


        

        drop_enemies(enemy_list)

        SCORE = update_enemy_positions(enemy_list, SCORE)

        SPEED = set_level(SCORE, SPEED)


        text = "Score:" + " " + str(SCORE)
        label = myFont.render(text, 1, BLACK)
        gameDisplay.blit(label, (WIDTH-200, HEIGHT-40))


        if collision_check(enemy_list, player_pos):
            message_display('Game Over!')

        draw_enemies(enemy_list)

        pygame.draw.rect(gameDisplay, BLACK, (player_pos[0]-2, player_pos[1]-2, 50, 50))
        pygame.draw.rect(gameDisplay, GREEN, (player_pos[0], player_pos[1], player_size, player_size))
        pygame.draw.rect(gameDisplay, BLUE, (middle_line_pos[0], middle_line_pos[1], WIDTH, 2))

        clock.tick(30)

        pygame.display.update()


            #if game_over:
        #print("Game Over!")
        #print("You're score is" + " " + str(SCORE)) 
       # print("Try again!")
   #else:
        #pass

game_intro()

pygame.quit()
quit()

SheeppOSU · (This post was last modified: May-19-2019, 05:27 PM by SheeppOSU.)

I know for sure I fixed the score problem. The speed should work, but it wasn't when i tested it... So i must've done something wrong

import pygame
import time
import random
import sys
  
pygame.init()
  
intro = True
 
WIDTH = 800
HEIGHT = 600
  
BLACK = (0,0,0)
WHITE = (255,255,255)
RED_B = (255,0,0)
GREEN_B = (0,255,0)
YELLOW = (255,255,0)
BLUE_B = (0,0,255)
RED = (200,0,0)
BLUE = (0,0,200)
GREEN = (0,200,0)
 
 
middle_line_pos = [0, HEIGHT/2]
 
player_size = 46
player_pos = [WIDTH/2-player_size/2, HEIGHT-2*player_size]
player_x = player_pos[0]
player_y = player_pos[1]
 
enemy_size = 46
enemy_pos = [random.randint(0, WIDTH-enemy_size), 0]
enemy_list = [enemy_pos]
 
 
game_over = False
 
SCORE = 0
SPEED = 10
 
myFont = pygame.font.SysFont("monospace", 35)
 
  
gameDisplay = pygame.display.set_mode((WIDTH,HEIGHT))
pygame.display.set_caption('Dodge the Blocks')
clock = pygame.time.Clock()
 
  
 
def set_level(SCORE, SPEED):
 
    SPEED = SCORE/15 + 5
 
    return SPEED
 
 
def drop_enemies(enemy_list):
    delay = random.random()
    if len(enemy_list) < 10 and delay < 0.1:
        x_pos = random.randint(0, WIDTH-enemy_size)
        y_pos = 0
        enemy_list.append([x_pos, y_pos])
 
 
def draw_enemies(enemy_list):
    for enemy_pos in enemy_list:
        pygame.draw.rect(gameDisplay, BLACK, (enemy_pos[0]-2, enemy_pos[1]-2, 50, 50))
        pygame.draw.rect(gameDisplay, RED, (enemy_pos[0], enemy_pos[1], enemy_size, enemy_size))
 
 
def update_enemy_positions(enemy_list, SCORE, SPEED, player_pos_y):
    for idx, enemy_pos in enumerate(enemy_list):
        if enemy_pos[1] >= 0 and enemy_pos[1] < HEIGHT:
            enemy_pos[1] += SPEED
        else:
            if player_pos_y < HEIGHT/2:
                enemy_list.pop(idx)
                SCORE += 2
 
            else:
                enemy_list.pop(idx)
                SCORE += 1
    return SCORE
 
def detect_collision(player_pos, enemy_pos):
 
    p_x = player_pos[0]
    p_y = player_pos[1]
    e_x = enemy_pos[0]
    e_y = enemy_pos[1]
 
    if ((e_x >= p_x and e_x <= (p_x + player_size)) or (p_x >= e_x and p_x <= (e_x + enemy_size))):
        if (e_y >= p_y and e_y <= (p_y + player_size) or (p_y >= e_y and p_y <= (e_y + enemy_size))):
            return True
    return False
 
 
 
def collision_check(enemy_list, player_pos):
    for enemy_pos in enemy_list:
        if detect_collision(enemy_pos, player_pos):
            return True
    return False
 
 
 
def text_objects(text, font):
    textSurface = font.render(text, True, BLACK)
    return textSurface, textSurface.get_rect()
  
def message_display(text):
    largeText = pygame.font.Font('freesansbold.ttf',75)
    TextSurf, TextRect = text_objects(text, largeText)
    TextRect.center = ((HEIGHT/2),(WIDTH/2))
    gameDisplay.blit(TextSurf, TextRect)
  
    pygame.display.update()
  
    time.sleep(2)
  
    pygame.quit()
    quit()
     
 
 
 
 
def button(msg,x,y,w,h,ic,ac,action=None):
     
    mouse = pygame.mouse.get_pos()
 
    click = pygame.mouse.get_pressed()
 
    if x+w > mouse[0] > x and y+h > mouse[1] > y:
        pygame.draw.rect(gameDisplay, ac,(x,y,w,h))
        if click[0] == 1 and action != None:
 
            if action == "play":
                game_loop()
            elif action == "quit":
                pygame.quit()
                quit()
 
  
 
 
 
 
 
def game_intro():
 
    intro = True
 
    while intro:
        for event in pygame.event.get():
            #print(event)
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
                 
        gameDisplay.fill(BLUE)
        largeText = pygame.font.Font('freesansbold.ttf',75)
        TextSurf, TextRect = text_objects("Dodge the Blocks", largeText)
        TextRect.center = ((WIDTH/2),(HEIGHT/4))
        gameDisplay.blit(TextSurf, TextRect)
 
        mouse = pygame.mouse.get_pos()
        if 150+150 > mouse[0] > 125 and 350+50 > mouse[1] > 350:
            pygame.draw.rect(gameDisplay, GREEN_B,(125,350,150,50))
        else:
             pygame.draw.rect(gameDisplay, GREEN,(125,350,150,50))
        if 150+525 > mouse[0] > 525 and 350+50 > mouse[1] > 350:
            pygame.draw.rect(gameDisplay, RED_B,(525,350,150,50))
        else:
            pygame.draw.rect(gameDisplay, RED,(525,350,150,50))
 
        button("Singleplayer", 125, 350, 150, 50, GREEN, GREEN_B, "play")
        button("Multiplayer", 525, 350, 150, 50, RED, RED_B, "quit")
 
        smallText = pygame.font.Font("freesansbold.ttf",20)
        textSurf, textRect = text_objects("Singleplayer", smallText)
        textRect.center = ( (150+(100/2)), (350+(50/2)) )
        gameDisplay.blit(textSurf, textRect)
 
        smallText = pygame.font.Font("freesansbold.ttf",20)
        textSurf, textRect = text_objects("Multiplayer", smallText)
        textRect.center = ( (75+(525)), (350+(50/2)) )
        gameDisplay.blit(textSurf, textRect)
 
 
        pygame.display.update()
        clock.tick(15)
 
    ########################################################################
 
        #if game_over:
        #print("Game Over!")
        #print("You're score is" + " " + str(SCORE)) 
       # print("Try again!")
   #else:
        #pass
 
def game_loop():
 
    game = True
 
    middle_line_pos = [0, HEIGHT/2]
 
    player_size = 46
    player_pos = [WIDTH/2-player_size/2, HEIGHT-2*player_size]
    player_x = player_pos[0]
    player_y = player_pos[1]
 
    enemy_size = 46
    enemy_pos = [random.randint(0, WIDTH-enemy_size), 0]
    enemy_list = [enemy_pos]
     
    SPEED = 5
 
    SCORE = 0
 
    while game:
 
 
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
 
            if event.type == pygame.KEYDOWN:
 
                x = player_pos[0]
                y = player_pos[1]
 
                if event.key == pygame.K_LEFT or event.key == pygame.K_a:
                    x -= player_size
 
                elif event.key == pygame.K_RIGHT or event.key == pygame.K_d:
                    x += player_size
 
                elif event.key == pygame.K_UP or event.key == pygame.K_w:
                    y -= player_size
 
                elif event.key == pygame.K_DOWN or event.key == pygame.K_s:
                    y += player_size
 
                player_pos = [x, y]
 
 
        gameDisplay.fill(WHITE)
 
        #if enemy_pos[1] >= 0 and enemy_pos[1] < HEIGHT:
            #enemy_pos[1] += SPEED
        #else:
            #enemy_pos[0] = random.randint(0, WIDTH-enemy_size)
            #enemy_pos[1] = 1
 
         
 
        if detect_collision(player_pos, enemy_pos):
 
            message_display('Game Over!')
 
        elif (player_pos[0] < 0) or (player_pos[0] > WIDTH-player_size) or (player_pos[1] < 0) or (player_pos[1] > HEIGHT-player_size):
 
            message_display('Game Over!')
         
 
        drop_enemies(enemy_list)
 
        SCORE = update_enemy_positions(enemy_list, SCORE, SPEED, player_pos[1])
 
        SPEED = set_level(SCORE, SPEED)
 
 
        text = "Score:" + " " + str(SCORE)
        label = myFont.render(text, 1, BLACK)
        gameDisplay.blit(label, (WIDTH-200, HEIGHT-40))
 
 
        if collision_check(enemy_list, player_pos):
            message_display('Game Over!')
 
        draw_enemies(enemy_list)
 
        pygame.draw.rect(gameDisplay, BLACK, (player_pos[0]-2, player_pos[1]-2, 50, 50))
        pygame.draw.rect(gameDisplay, GREEN, (player_pos[0], player_pos[1], player_size, player_size))
        pygame.draw.rect(gameDisplay, BLUE, (middle_line_pos[0], middle_line_pos[1], WIDTH, 2))
 
        clock.tick(30)
 
        pygame.display.update()
 
 
            #if game_over:
        #print("Game Over!")
        #print("You're score is" + " " + str(SCORE)) 
       # print("Try again!")
   #else:
        #pass
 
game_intro()
 
pygame.quit()
quit()

Ok I fixed the speed -

import pygame
import time
import random
import sys
  
pygame.init()
  
intro = True
 
WIDTH = 800
HEIGHT = 600
  
BLACK = (0,0,0)
WHITE = (255,255,255)
RED_B = (255,0,0)
GREEN_B = (0,255,0)
YELLOW = (255,255,0)
BLUE_B = (0,0,255)
RED = (200,0,0)
BLUE = (0,0,200)
GREEN = (0,200,0)
 
 
middle_line_pos = [0, HEIGHT/2]
 
player_size = 46
player_pos = [WIDTH/2-player_size/2, HEIGHT-2*player_size]
player_x = player_pos[0]
player_y = player_pos[1]
 
enemy_size = 46
enemy_pos = [random.randint(0, WIDTH-enemy_size), 0]
enemy_list = [enemy_pos]
 
 
game_over = False
 
SCORE = 0
SPEED = 10
 
myFont = pygame.font.SysFont("monospace", 35)
 
  
gameDisplay = pygame.display.set_mode((WIDTH,HEIGHT))
pygame.display.set_caption('Dodge the Blocks')
clock = pygame.time.Clock()
 
  
 
def set_level(SCORE, SPEED):
 
    SPEED = SCORE/15 + 5
 
    return SPEED
 
 
def drop_enemies(enemy_list):
    delay = random.random()
    if len(enemy_list) < 10 and delay < 0.1:
        x_pos = random.randint(0, WIDTH-enemy_size)
        y_pos = 0
        enemy_list.append([x_pos, y_pos])
 
 
def draw_enemies(enemy_list):
    for enemy_pos in enemy_list:
        pygame.draw.rect(gameDisplay, BLACK, (enemy_pos[0]-2, enemy_pos[1]-2, 50, 50))
        pygame.draw.rect(gameDisplay, RED, (enemy_pos[0], enemy_pos[1], enemy_size, enemy_size))
 
 
def update_enemy_positions(enemy_list, SCORE, SPEED, player_pos_y, enemy_List):
    for idx, enemy_pos in enumerate(enemy_List):
        if enemy_pos[1] >= 0 and enemy_pos[1] < HEIGHT:
            enemy_pos[1] += SPEED
        else:
            if player_pos_y < HEIGHT/2:
                SCORE += 2
 
            else:
                SCORE += 1
            enemy_List.pop(idx)
    return SCORE, enemy_List
 
def detect_collision(player_pos, enemy_pos):
 
    p_x = player_pos[0]
    p_y = player_pos[1]
    e_x = enemy_pos[0]
    e_y = enemy_pos[1]
 
    if ((e_x >= p_x and e_x <= (p_x + player_size)) or (p_x >= e_x and p_x <= (e_x + enemy_size))):
        if (e_y >= p_y and e_y <= (p_y + player_size) or (p_y >= e_y and p_y <= (e_y + enemy_size))):
            return True
    return False
 
 
 
def collision_check(enemy_list, player_pos):
    for enemy_pos in enemy_list:
        if detect_collision(enemy_pos, player_pos):
            return True
    return False
 
 
 
def text_objects(text, font):
    textSurface = font.render(text, True, BLACK)
    return textSurface, textSurface.get_rect()
  
def message_display(text):
    largeText = pygame.font.Font('freesansbold.ttf',75)
    TextSurf, TextRect = text_objects(text, largeText)
    TextRect.center = ((HEIGHT/2),(WIDTH/2))
    gameDisplay.blit(TextSurf, TextRect)
  
    pygame.display.update()
  
    time.sleep(2)
  
    pygame.quit()
    quit()
     
 
 
 
 
def button(msg,x,y,w,h,ic,ac,action=None):
     
    mouse = pygame.mouse.get_pos()
 
    click = pygame.mouse.get_pressed()
 
    if x+w > mouse[0] > x and y+h > mouse[1] > y:
        pygame.draw.rect(gameDisplay, ac,(x,y,w,h))
        if click[0] == 1 and action != None:
 
            if action == "play":
                game_loop()
            elif action == "quit":
                pygame.quit()
                quit()
 
  
 
 
 
 
 
def game_intro():
 
    intro = True
 
    while intro:
        for event in pygame.event.get():
            #print(event)
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
                 
        gameDisplay.fill(BLUE)
        largeText = pygame.font.Font('freesansbold.ttf',75)
        TextSurf, TextRect = text_objects("Dodge the Blocks", largeText)
        TextRect.center = ((WIDTH/2),(HEIGHT/4))
        gameDisplay.blit(TextSurf, TextRect)
 
        mouse = pygame.mouse.get_pos()
        if 150+150 > mouse[0] > 125 and 350+50 > mouse[1] > 350:
            pygame.draw.rect(gameDisplay, GREEN_B,(125,350,150,50))
        else:
             pygame.draw.rect(gameDisplay, GREEN,(125,350,150,50))
        if 150+525 > mouse[0] > 525 and 350+50 > mouse[1] > 350:
            pygame.draw.rect(gameDisplay, RED_B,(525,350,150,50))
        else:
            pygame.draw.rect(gameDisplay, RED,(525,350,150,50))
 
        button("Singleplayer", 125, 350, 150, 50, GREEN, GREEN_B, "play")
        button("Multiplayer", 525, 350, 150, 50, RED, RED_B, "quit")
 
        smallText = pygame.font.Font("freesansbold.ttf",20)
        textSurf, textRect = text_objects("Singleplayer", smallText)
        textRect.center = ( (150+(100/2)), (350+(50/2)) )
        gameDisplay.blit(textSurf, textRect)
 
        smallText = pygame.font.Font("freesansbold.ttf",20)
        textSurf, textRect = text_objects("Multiplayer", smallText)
        textRect.center = ( (75+(525)), (350+(50/2)) )
        gameDisplay.blit(textSurf, textRect)
 
 
        pygame.display.update()
        clock.tick(15)
 
    ########################################################################
 
        #if game_over:
        #print("Game Over!")
        #print("You're score is" + " " + str(SCORE)) 
       # print("Try again!")
   #else:
        #pass
 
def game_loop():
 
    game = True
 
    middle_line_pos = [0, HEIGHT/2]
 
    player_size = 46
    player_pos = [WIDTH/2-player_size/2, HEIGHT-2*player_size]
    player_x = player_pos[0]
    player_y = player_pos[1]
 
    enemy_size = 46
    enemy_pos = [random.randint(0, WIDTH-enemy_size), 0]
    enemy_list = [enemy_pos]
    
    SPEED = 5
 
    SCORE = 0
 
    while game:
 
 
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
 
            if event.type == pygame.KEYDOWN:
 
                x = player_pos[0]
                y = player_pos[1]
 
                if event.key == pygame.K_LEFT or event.key == pygame.K_a:
                    x -= player_size
 
                elif event.key == pygame.K_RIGHT or event.key == pygame.K_d:
                    x += player_size
 
                elif event.key == pygame.K_UP or event.key == pygame.K_w:
                    y -= player_size
 
                elif event.key == pygame.K_DOWN or event.key == pygame.K_s:
                    y += player_size
 
                player_pos = [x, y]
 
 
        gameDisplay.fill(WHITE)
 
        #if enemy_pos[1] >= 0 and enemy_pos[1] < HEIGHT:
            #enemy_pos[1] += SPEED
        #else:
            #enemy_pos[0] = random.randint(0, WIDTH-enemy_size)
            #enemy_pos[1] = 1
 
         
 
        if detect_collision(player_pos, enemy_pos):
 
            message_display('Game Over!')
 
        elif (player_pos[0] < 0) or (player_pos[0] > WIDTH-player_size) or (player_pos[1] < 0) or (player_pos[1] > HEIGHT-player_size):
 
            message_display('Game Over!')
         
 
        drop_enemies(enemy_list)
 
        output = update_enemy_positions(enemy_list, SCORE, SPEED, player_pos[1], enemy_list)
        SCORE = output[0]
        enemy_list = output[1]
 
        SPEED = set_level(SCORE, SPEED)
 
 
        text = "Score:" + " " + str(SCORE)
        label = myFont.render(text, 1, BLACK)
        gameDisplay.blit(label, (WIDTH-200, HEIGHT-40))
 
 
        if collision_check(enemy_list, player_pos):
            message_display('Game Over!')
 
        draw_enemies(enemy_list)
 
        pygame.draw.rect(gameDisplay, BLACK, (player_pos[0]-2, player_pos[1]-2, 50, 50))
        pygame.draw.rect(gameDisplay, GREEN, (player_pos[0], player_pos[1], player_size, player_size))
        pygame.draw.rect(gameDisplay, BLUE, (middle_line_pos[0], middle_line_pos[1], WIDTH, 2))
 
        clock.tick(30)
 
        pygame.display.update()
 
 
            #if game_over:
        #print("Game Over!")
        #print("You're score is" + " " + str(SCORE)) 
       # print("Try again!")
   #else:
        #pass
 
game_intro()
 
pygame.quit()
quit()

Darkseige · May-19-2019, 05:48 PM

Thank you very much! I see you added a new variable representing the function... I sure will keep that trick in mind later on. Now time to fix that disgusting Game Over window xD

***metulburr*** · (This post was last modified: May-19-2019, 08:57 PM by metulburr.)

(May-19-2019, 02:57 PM)Darkseige Wrote: The game works just fine and I am looking to improve it.

A good way to improve your game would be to use a single game loop instead of one for each state. This will help simplify things if you plan on expanding the game further. However it takes some reworking of your current structure. Your game intro function is really your main menu state, while your game_loop function is your game state. Your game over screen would be another one.

This is a tutorial of that structure. Notice that there is only ever one while loop and pygame.display.update() line in the entire program while having the same utilization of multiple states. Having more than one of these is an easy indication that you are making spaghetti code.

This (at the bottom of the post) is an example of your code (the first code snippet) and what would make it easier (the second code snippet)

This entire process simplifies things. It is a lot easier to find bugs with this style than trying to morph numerous game loops that cause hard to diagnose bugs. Everything pertaining to one state is only in that on class. You know where to look to find the bug.

Another thing that would make your life easier is utilizing classes. For one the enemy should be its own class. If you had one all things relating to that enemy should be within the class.

Another improvement would be to utilize pygame rects. A simple collision instead of this:

    if ((e_x >= p_x and e_x <= (p_x + player_size)) or (p_x >= e_x and p_x <= (e_x + enemy_size))):
        if (e_y >= p_y and e_y <= (p_y + player_size) or (p_y >= e_y and p_y <= (e_y + enemy_size))):
            return True
    return False

could be this:

if player.rect.colliderectlist(enemies):
   return true

Windspar · May-20-2019, 04:09 AM

Code very ugly. Need to learn to use containers. Even in functional language use containers.
Choice between class-object, class-variables, or dict.

Never use time.sleep. I won't even run code with this in it.
Learn to use main loop and pygame.time.get_ticks() for this.

SCORE and SPEED should be lower case. Capital case only use for constants.

WIDTH and HEIGHT should not be constants. You can always handle different display later.

No since in define colors. Pygame has colors builtin over 400. Code below showing builtin colors.

import pygame
from pygame.sprite import Group, Sprite
 
class SimpleButton(Sprite):
    def __init__(self, font, text, rect, callback, foreground, background, midground):
        Sprite.__init__(self)
 
        self.font = font
        self.rect = rect
        self.hover = False
        self.callback = callback
        self.midground = midground
        self.foreground = foreground
        self.background = background
        self.image = pygame.Surface(self.rect.size)
        self.text(text)
 
    def text(self, text):
        self.text_image = self.font.render(text, 1, self.foreground)
        self.update_image()
 
    def on_mousemotion(self, event):
        hover = self.rect.collidepoint(event.pos)
        if self.hover != hover:
            self.hover = hover
            self.update_image()
 
    def on_mousebuttonup(self, event):
        if event.button == 1:
            if self.hover:
                self.callback(self)
 
    def update_image(self):
        if self.hover:
            self.image.fill(self.midground)
        else:
            self.image.fill(self.background)
 
        rect = self.image.get_rect()
        text_rect = self.text_image.get_rect()
        text_rect.center = rect.center
        self.image.blit(self.text_image, text_rect)
 
class TextBlock(Sprite):
    def __init__(self, font, text, rect):
        Sprite.__init__(self)
 
        self.font = font
        self.rect = rect
        self.image = pygame.Surface(self.rect.size)
        self.text(text)
 
    def colors(self, text):
        if text:
            bg = self.background = pygame.Color(text)
            if bg.r < 128 and bg.g < 128:
                self.foreground = pygame.Color('white')
            else:
                self.foreground = pygame.Color('Black')
        else:
            self.background = pygame.Color('Black')
 
    def text(self, text):
        self.colors(text)
        self.image.fill(self.background)
 
        if text:
            text_image = self.font.render(text, 1, self.foreground)
 
            rect = self.image.get_rect()
            text_rect = text_image.get_rect()
            text_rect.center = rect.center
            self.image.blit(text_image, text_rect)
 
class ColorState:
    def __init__(self):
        # color keys
        self.keys = pygame.color.THECOLORS.keys()
        for color in ("gray", "grey"):
            self.keys = [k for k in self.keys if color not in k]
 
        self.keys.sort()
        self.position = 0
        self.sprites = Group()
        self.buttons = Group()
        self.blocks = Group()
        self.font = pygame.font.Font(None, 24)
 
        for x in range(5):
            for y in range(10):
                pos = x * 10 + y
                rect = pygame.Rect(25 + x * 150, 10 + y * 50, 140, 40)
                block = TextBlock(self.font, self.keys[pos], rect)
                block.add(self.sprites, self.blocks)
 
        colors = pygame.Color("White"), pygame.Color("Navy"), pygame.Color("Dodgerblue")
        rect = pygame.Rect(405, 550, 100, 40)
        button = SimpleButton(self.font, ">>", rect, self.color_forwards, *colors)
        button.add(self.sprites, self.buttons)
 
        rect = pygame.Rect(295, 550, 100, 40)
        button = SimpleButton(self.font, "<<", rect, self.color_backwards, *colors)
        button.add(self.sprites, self.buttons)
 
    def color_forwards(self, button):
        length = len(self.keys)
        if self.position + 50 < length:
            self.position += 50
 
            for enum, sprite in enumerate(self.blocks):
                pos = self.position + enum
                if pos < length:
                    sprite.text(self.keys[pos])
                else:
                    sprite.text(None)
 
    def color_backwards(self, button):
        if self.position >= 50:
            self.position -= 50
            length = len(self.keys)
           
            for enum, sprite in enumerate(self.blocks):
                pos = self.position + enum
                if pos < length:
                    sprite.text(self.keys[pos])
                else:
                    sprite.text(None)
 
    def draw(self, surface):
        self.sprites.draw(surface)
 
    def event(self, event):
        if event.type == pygame.MOUSEMOTION:
            for sprite in self.buttons:
                sprite.on_mousemotion(event)
 
        elif event.type == pygame.MOUSEBUTTONUP:
            for sprite in self.buttons:
                sprite.on_mousebuttonup(event)
 
class ColorMachine:
    def __init__(self):
        # basic pygame setup
        pygame.display.set_caption("Pygame Builtin Colors")
        self.surface = pygame.display.set_mode((800, 600))
        self.rect = self.surface.get_rect()
        self.clock = pygame.time.Clock()
 
        # State
        self.state = ColorState()
 
    def mainloop(self):
        running = True
        while running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
                else:
                    self.state.event(event)
 
            self.state.draw(self.surface)
            pygame.display.update()
            self.clock.tick(30)
 
def main():
    pygame.init()
    machine = ColorMachine()
    machine.mainloop()
    pygame.quit()
 
main()

Learn the basic of pygame. Use them or forget being help.
pygame.Rect and pygame.Vector2. pygame.Vector2 is not experimental any more.

player_size = 46
player_pos = [WIDTH/2-player_size/2, HEIGHT-2*player_size]
player_x = player_pos[0]
player_y = player_pos[1]

Can be done as class-varaible. This is only good for 1 player.

rect = pygame.Rect(0, 0, 800, 600)
class Player:
    size = 46
    pos = pygame.Vector2(rect.width / 2 - size / 2, rect.height - size * 2)

print(Player.size)
print(Player.pos.x)
print(Player.pos.y)

or class-object good for multiply players

rect = pygame.Rect(0, 0, 800, 600)
class Player:
    def __init__(self, size, rect):
        self.size = size
        self.pos = pygame.Vector2(rect.width / 2 - size / 2, rect.height - size * 2)

player = Player(46, rect)

or you can do it with dicts

rect = pygame.Rect(0, 0, 800, 600)
size = 46
player = {
    'size': size,
    'pos': Vector2(rect.width / 2 - size / 2, rect.height - size * 2)
}

Button is going to need more function then one. You never recreate every loop.
1. Create button function. Store all button variables.
2. Draw function.
3. Click function. Check if mouse is hovering and mouse button been click.

[PyGame] Can't figure out my problem...

User Panel Messages

Announcements