la voiture se déplace et change de direction lorsqu'elle heurte le bord de la fenêtre [fermée]

Question

La voiture roule tout droit. Lorsqu'il touche le bord de la fenêtre, il se déplace vers l'arrière puis change de direction à un angle de 45 degrés dans le sens des aiguilles d'une montre et continue de se déplacer droit. s'il touchait à nouveau le bord de la fenêtre, il ferait de même

J'ai créé le code ci-dessous. Je n'ai pu arrêter et reculer la voiture que lorsqu'elle a heurté le bord de la vitre. Comment changer la direction de la voiture, la faire aller tout droit, et maintenir le programme en marche et il ne s'arrêtera que si nous fermons la fenêtre?

import pygame, sys
from pygame.locals import *

def base(cX,cY):
    screen.fill(whitdull)
    pygame.draw.rect(screen,whitdull,[0,0,1050,600],4)
    
    screen.blit(text1,[150,230])
    
    # Copy image to screen:
    screen.blit(player_image, [cX,cY])
    
    pygame.display.flip()
    clock.tick(ct)


def carMovement(b0XX,b0YY,bDirection):
    sX = 5      # 5 pixel/clock  Direction right-left
    sY = 5      # 5 pixel/clock  Direction upward-downward
    
    while True:
        
        # Direction to the right
        pX = sX
        pY = 0
        
        b0XX = b0XX + pX
        b0YY = b0YY + pY
        if b0XX == 970:
            b0XX = 970 - sX
            backward(b0XX,b0YY,Direction)
            
        # Copy image to screen:
        base(b0XX,b0YY)

    return b0XX,b0YY

def backward(b0XX,b0YY,bDirection):
    sX = 5      # 5 pixel/clock  Direction right-left
    sY = 5      # 5 pixel/clock  Direction upward-downward
    
    while b0XX >= 900:
        
        # Direction to the right
        pX = sX
        pY = 0
        
        b0XX = b0XX - pX
        b0YY = b0YY - pY
        if b0XX == 900:
            b0XX = 900 + sX
            
            
        base(b0XX,b0YY)
    return b0XX, b0YY

# Initialize Pygame
pygame.init()

# Define some colors
white=(250,250,250);   whitdull=(247,247,247)
black=(70,70,70)   ;   blue =(45,127,184) 
gold  =(248,179,35);   green=(0,176,80)
yellow=(254,240,11);   gray=(208,206,206)

#Setting font-size
font1 = pygame.font.Font(None,150)

text1 = font1.render("Bom-bom  Car",True,white)


# preparing  the  screen
width = 1050 ; height = 600
screen = pygame.display.set_mode([width, height])
pygame.display.set_caption('Bom-bom Car')
screen.fill(whitdull) 


player_image = pygame.image.load("Car-2.jpeg").convert()
#rotasi = pygame.transform.rotate(player_image, -45)


#initial condition
b0X = 0; b0Y = 250; Direction = 2      # initial car position, Direction 2 = to the right

ct = 20
clock = pygame.time.Clock()


# program utama Pygame
while True:
        
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
        if event.type == pygame.MOUSEBUTTONDOWN:
            b0X,b0Y = carMovement(b0X,b0Y,Direction)
            
    base(b0X,b0Y)
    
    # Get the current mouse position (x,y)
    player_position = pygame.mouse.get_pos()
    xm=player_position[0]
    ym=player_position[1]
       
#end program

production

source d'image

Answer 1

N'implémentez jamais de boucles supplémentaires pour contrôler le jeu. Vous avez la boucle d'application. Utilise le!

Utilisez des pygame.math.Vector2objets pour définir la position et le mouvement du joueur. Le mouvement initial est (0, 0). Définissez en plus une vitesse pour le joueur:

player_pos = pygame.math.Vector2(player_image.get_width() // 2, screen.get_height() // 2)
player_move = pygame.math.Vector2(0, 0)
speed = 10

Dès que vous appuyez sur la souris, définissez la direction du mouvement et mettez à l'échelle la longueur du vecteur de mouvement par le speedavec scale_to_length():

if event.type == pygame.MOUSEBUTTONDOWN:
    dx = event.pos[0] - player_pos.x
    dy = event.pos[1] - player_pos.y
    if dx != 0 or dY != 0:
        player_move = pygame.math.Vector2(dx, dy)
        player_move.scale_to_length(speed)

Additionnez le vecteur de mouvement ( player_move) à la position du lecteur ( player_pos) dans la boucle d'application:

while True:
    # [...]

    player_pos += player_move

Obtenez le rectangle englobant du joueur. Je recommande de lire Pourquoi mon test de collision retourne toujours `` vrai '' et pourquoi la position du rectangle de l'image est-elle toujours fausse (0, 0)? :

player_rect = player_image.get_rect(center = (round(player_pos.x), round(player_pos.y)))

Une fois que le joueur atteint les bords de la fenêtre, réfléchissez le joueur sur les bords comme une boule de billard. Voir aussi Comment faire rebondir la balle sur le mur avec Pygame? :

if player_rect.left < 0:
    player_rect.left = 0 
    player_pos.x = player_rect.centerx
    player_move.x = abs(player_move.x)
if player_rect.right > screen.get_width():
    player_rect.right = screen.get_width()
    player_pos.x = player_rect.centerx
    player_move.x = -abs(player_move.x)
if player_rect.top < 0:
    player_rect.top = 0 
    player_pos.y = player_rect.centery
    player_move.y = abs(player_move.y)
if player_rect.bottom > screen.get_height():
    player_rect.bottom = screen.get_height()
    player_pos.y = player_rect.centery
    player_move.y = -abs(player_move.y)

Calculez l'angle du vecteur de mouvement et faites pivoter le lecteur autour de son centre. Voir Comment faire pivoter une image autour de son centre à l'aide de PyGame? et Comment faire pivoter une image (lecteur) dans le sens de la souris? :

angle = player_move.angle_to((1, 0))
rotated_player = pygame.transform.rotate(player_image, angle)
rotated_rect = rotated_player.get_rect(center = player_rect.center)

Enfin redessinez la scène:

screen.fill(whitdull)
pygame.draw.rect(screen, whitdull,[0,0,1050,600],4)
screen.blit(text1,[150,230])
screen.blit(rotated_player, rotated_rect)
pygame.display.flip()

---

Exemple complet:

import pygame, sys
from pygame.locals import *

# Initialize Pygame
pygame.init()
clock = pygame.time.Clock()

# Define some colors
white=(250,250,250);   whitdull=(247,247,247)
black=(70,70,70)   ;   blue =(45,127,184) 
gold  =(248,179,35);   green=(0,176,80)
yellow=(254,240,11);   gray=(208,206,206)

#Setting font-size
font1 = pygame.font.Font(None,150)
text1 = font1.render("Bom-bom  Car",True,white)

# preparing  the  screen
width, height = 1050, 600
screen = pygame.display.set_mode([width, height])
pygame.display.set_caption('Bom-bom Car')

player_image = pygame.image.load("Car-2.jpeg").convert()

#initial condition
ct = 20
player_pos = pygame.math.Vector2(player_image.get_width() // 2, screen.get_height() // 2)
player_move = pygame.math.Vector2(0, 0)
speed = 10

# program utama Pygame
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
        if event.type == pygame.MOUSEBUTTONDOWN:
            dx = event.pos[0] - player_pos.x
            dy = event.pos[1] - player_pos.y
            if dx != 0 or dY != 0:
                player_move = pygame.math.Vector2(dx, dy)
                player_move.scale_to_length(speed)

    player_pos += player_move
    player_rect = player_image.get_rect(center = (round(player_pos.x), round(player_pos.y)))
    if player_rect.left < 0:
       player_rect.left = 0 
       player_pos.x = player_rect.centerx
       player_move.x = abs(player_move.x)
    if player_rect.right > screen.get_width():
       player_rect.right = screen.get_width()
       player_pos.x = player_rect.centerx
       player_move.x = -abs(player_move.x)
    if player_rect.top < 0:
       player_rect.top = 0 
       player_pos.y = player_rect.centery
       player_move.y = abs(player_move.y)
    if player_rect.bottom > screen.get_height():
       player_rect.bottom = screen.get_height()
       player_pos.y = player_rect.centery
       player_move.y = -abs(player_move.y)

    angle = player_move.angle_to((1, 0))
    rotated_player = pygame.transform.rotate(player_image, angle)
    rotated_rect = rotated_player.get_rect(center = player_rect.center)
    
    screen.fill(whitdull)
    pygame.draw.rect(screen, whitdull,[0,0,1050,600],4)
    screen.blit(text1,[150,230])
    screen.blit(rotated_player, rotated_rect)    
    pygame.display.flip()
    clock.tick(ct)