Das Auto bewegt sich und ändert die Richtung, wenn es die Fensterkante berührt. [geschlossen]

Nov 25 2020

Das Auto fährt geradeaus. Wenn es auf die Fensterkante trifft, bewegt es sich rückwärts, ändert dann die Richtung in einem Winkel von 45 Grad im Uhrzeigersinn und bewegt sich geradeaus weiter. Wenn es erneut gegen den Rand des Fensters stößt, wird es dasselbe tun

Ich habe den Code unten gemacht. Ich konnte das Auto nur anhalten und rückwärts fahren, wenn es am Rand des Fensters aufschlug. Wie kann man die Richtung des Autos ändern, es geradeaus fahren und das Programm laufen lassen, und es stoppt nur, wenn wir das Fenster schließen?

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

Ausgabe

Bildquelle

Antworten

Rabbid76 Nov 25 2020 at 18:10

Implementieren Sie niemals zusätzliche Schleifen, um das Spiel zu steuern. Sie haben die Anwendungsschleife. Benutze es!

Verwenden Sie pygame.math.Vector2Objekte, um die Position und Bewegung des Spielers zu definieren. Die anfängliche Bewegung ist (0, 0). Definieren Sie zusätzlich eine Geschwindigkeit für den Spieler:

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

Sobald die Maus gedrückt wird, definieren Sie die Bewegungsrichtung und skalieren Sie die Länge des Bewegungsvektors speedmit 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)

Addieren Sie den Bewegungsvektor ( player_move) zur Position des Players ( player_pos) in der Anwendungsschleife:

while True:
    # [...]

    player_pos += player_move

Holen Sie sich das Begrenzungsrechteck des Players. Ich empfehle zu lesen, warum mein Kollisionstest immer "wahr" zurückgibt und warum die Position des Rechtecks des Bildes immer falsch ist (0, 0)? ::

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

Sobald der Spieler die Ränder des Fensters erreicht hat, reflektieren Sie den Spieler an den Rändern wie eine Billardkugel. Siehe auch Wie man mit Pygame den Ball von der Wand hüpfen lässt? ::

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)

Berechnen Sie den Winkel des Bewegungsvektors und drehen Sie den Player um seine Mitte. Siehe Wie drehe ich ein Bild mit PyGame um seine Mitte? und Wie drehe ich ein Bild (Player) in Mausrichtung? ::