Hola a todos, este artículo se centrará en 100 líneas de código de juego simple de Python. Lo que el código de juego de Python puede usar es algo que mucha gente quiere entender. Si desea comprender el código fuente del programa de juego de Python, debe comprenderlo. Lo siguiente primero..
Esta vez, Python se usa para implementar un pequeño juego de atrapar pelotas y golpear ladrillos. Es necesario importar el módulo pygame. Hay dos resúmenes de experiencia de la siguiente manera:
1. Herencia de múltiples clases principales 2. Modelo matemático de detección de colisiones
Hablaremos de los puntos de conocimiento más adelante. Primero veamos los efectos y la implementación del juego:
1. Efecto del juego
2. Código del juego
#Importar módulo
importar pygame
desde pygame.locals importar *
importar sistema,aleatorio,tiempo,matemáticas
clase GameWindow(objeto):
'''Crear clase de ventana de juego'''
def __init__(self,*args,**kw):
self.window_length = 600
self.window_wide = 500
#Dibuja la ventana del juego y establece el tamaño de la ventana.
self.game_window = pygame.display.set_mode((self.window_length,self.window_wide))
#Establecer título de la ventana del juego
pygame.display.set_caption("CatchBallGame")
#Definir los parámetros de color de fondo de la ventana del juego
self.color_ventana = (135,206,250)
fondo def (yo):
#Dibuja el color de fondo de la ventana del juego.
self.game_window.fill(self.ventana_color)
clase Bola(objeto):
'''Crear una bola''''
def __init__(self,*args,**kw):
#Establece los parámetros de radio, color y velocidad de movimiento de la pelota.
self.ball_color = (255,215,0)
self.move_x = 1
self.move_y = 1
auto.radio = 10
def listo(yo):
#Establece la posición inicial de la pelota,
self.ball_x = self.mouse_x
self.ball_y = self.window_wide-self.rect_wide-self.radius
#Dibuja la pelota y establece las condiciones de activación del rebote.
pygame.draw.circle(self.game_window,self.ball_color,(self.ball_x,self.ball_y),self.radius)
def movimiento de pelota(yo):
#Dibuja la pelota y establece las condiciones de activación del rebote.
pygame.draw.circle(self.game_window,self.ball_color,(self.ball_x,self.ball_y),self.radius)
self.bola_x += self.move_x
self.ball_y -= self.move_y
# Función de detección de colisión de llamadas
self.ball_window()
self.ball_rect()
#La velocidad de la pelota se duplica cada 5 veces que se atrapa la pelota.
si auto.distancia < auto.radio:
frecuencia propia += 1
si frecuencia propia == 5:
auto.frecuencia = 0
self.move_x += self.move_x
self.move_y += self.move_y
punto.auto += punto.auto
#Establecer condiciones de falla del juego
si self.ball_y > 520:
self.gameover = self.over_font.render("Juego terminado",False,(0,0,0))
self.game_window.blit(self.gameover,(100,130))
self.over_sign = 1
clase Rect(objeto):
'''Crear clase de raqueta'''
def __init__(self,*args,**kw):
#Establecer parámetros de color de la raqueta
self.rect_color = (255,0,0)
self.rect_length = 100
self.rect_wide = 10
def movimiento recto(yo):
#Obtener parámetros de posición del mouse
self.mouse_x,self.mouse_y = pygame.mouse.get_pos()
#Dibuja la raqueta y limita los límites horizontales.
si self.mouse_x >= self.window_length-self.rect_length//2:
self.mouse_x = self.window_length-self.rect_length//2
si self.mouse_x <= self.rect_length//2:
self.mouse_x = self.rect_length//2
pygame.draw.rect(self.game_window,self.rect_color,((self.mouse_x-self.rect_length//2),(self.window_wide-self.rect_wide),self.rect_length,self.rect_wide))
clase Ladrillo(objeto):
def __init__(self,*args,**kw):
#Establecer parámetros de color de ladrillo
self.ladrillo_color = (139,126,102)
self.brick_list = [[1,1,1,1,1,1],[1,1,1,1,1,1],[1,1,1,1,1,1],[1, 1,1,1,1,1],[1,1,1,1,1,1]]
self.ladrillo_longitud = 80
self.brick_wide = 20
def organizar mosaicos (uno mismo):
para i en el rango(5):
para j en el rango(6):
self.ladrillo_x = j*(self.ladrillo_longitud+24)
self.ladrillo_y = i*(self.ladrillo_ancho+20)+40
si self.brick_list[i][j] == 1:
#dibujar ladrillos
pygame.draw.rect(self.game_window,self.brick_color,(self.brick_x,self.brick_y,self.brick_length,self.brick_wide))
# Función de detección de colisión de llamadas
self.ball_brick()
si auto.distanciab < auto.radio:
self.brick_list[i][j] = 0
puntuación propia += punto.auto
#Establecer condiciones de victoria del juego
si self.brick_list == [[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[ 0,0,0,0,0,0],[0,0,0,0,0,0]]:
self.win = self.win_font.render("Tú ganas",False,(0,0,0))
self.game_window.blit(self.win,(100,130))
self.win_sign = 1
Puntuación de clase (objeto):
'''Crear clase fraccionaria'''
def __init__(self,*args,**kw):
# Establecer puntuación inicial
puntuación propia = 0
#Establecer fuente de fracción
self.score_font = pygame.font.SysFont('arial',20)
#Establecer puntos de bonificación iniciales
auto.punto = 1
#Establecer el número inicial de capturas
auto.frecuencia = 0
def cuentapuntuación(yo):
#Trama las puntuaciones del jugador
my_score = self.score_font.render(str(self.score),False,(255,255,255))
self.game_window.blit(mi_puntuación,(555,15))
clase GameOver(objeto):
'''Crear juego sobre clase'''
def __init__(self,*args,**kw):
#Establecer fuente Game Over
self.over_font = pygame.font.SysFont('arial',80)
#Definir el logotipo de GameOver
self.over_sign = 0
clase Win(objeto):
'''Crear clase de victoria del juego'''
def __init__(self,*args,**kw):
#Establece fuente para ganar
self.win_font = pygame.font.SysFont('arial',80)
#Definir logotipo de Win
self.win_sign = 0
clase Colisión (objeto):
'''Clase de detección de colisiones'''
# Detección de colisiones entre la bola y el borde de la ventana
def ventana_bola(yo):
si self.ball_x <= self.radius o self.ball_x >= (self.window_length-self.radius):
self.move_x = -self.move_x
si self.ball_y <= self.radius:
self.move_y = -self.move_y
# Detección de colisión de pelota y raqueta
def bola_rect(yo):
#Definir identificador de colisión
self.collision_sign_x = 0
self.collision_sign_y = 0
si self.ball_x < (self.mouse_x-self.rect_length//2):
self.closestpoint_x = self.mouse_x-self.rect_length//2
self.collision_sign_x = 1
elif self.ball_x > (self.mouse_x+self.rect_length//2):
self.closestpoint_x = self.mouse_x+self.rect_length//2
self.collision_sign_x = 2
demás:
self.punto más cercano_x = self.ball_x
self.collision_sign_x = 3
si self.ball_y < (self.window_wide-self.rect_wide):
self.closestpoint_y = (self.window_wide-self.rect_wide)
self.collision_sign_y = 1
elif self.ball_y > self.window_wide:
self.closestpoint_y = self.window_wide
self.collision_sign_y = 2
demás:
self.closestpoint_y = self.ball_y
self.collision_sign_y = 3
#Define la distancia entre la raqueta y el punto más cercano al centro del círculo y al centro del círculo.
self.distance = math.sqrt(math.pow(self.closestpoint_x-self.ball_x,2)+math.pow(self.closestpoint_y-self.ball_y,2))
#Detección de colisión de la pelota en tres situaciones: izquierda, parte superior media y parte superior derecha de la raqueta.
si self.distance < self.radius y self.collision_sign_y == 1 y (self.collision_sign_x == 1 o self.collision_sign_x == 2):
si self.collision_sign_x == 1 y self.move_x > 0:
self.move_x = - self.move_x
self.move_y = - self.move_y
si self.collision_sign_x == 1 y self.move_x < 0:
self.move_y = - self.move_y
si self.collision_sign_x == 2 y self.move_x < 0:
self.move_x = - self.move_x
self.move_y = - self.move_y
si self.collision_sign_x == 2 y self.move_x > 0:
self.move_y = - self.move_y
si self.distance < self.radius y self.collision_sign_y == 1 y self.collision_sign_x == 3:
self.move_y = - self.move_y
#Detección de colisión de la pelota en el medio de los lados izquierdo y derecho de la raqueta
si self.distance < self.radius y self.collision_sign_y == 3:
self.move_x = - self.move_x
# Detección de colisiones entre bola y ladrillo.
def bola_ladrillo(yo):
#Definir identificador de colisión
self.collision_sign_bx = 0
self.collision_sign_by = 0
si self.ball_x < self.brick_x:
self.closestpoint_bx = self.ladrillo_x
self.collision_sign_bx = 1
elif self.ball_x > self.brick_x+self.brick_length:
self.closestpoint_bx = self.ladrillo_x+self.ladrillo_longitud
self.collision_sign_bx = 2
demás:
self.closestpoint_bx = self.ball_x
self.collision_sign_bx = 3
si self.ball_y < self.brick_y:
self.closestpoint_by = self.brick_y
self.collision_sign_by = 1
elif self.ball_y > self.brick_y+self.brick_wide:
self.closestpoint_by = self.brick_y+self.brick_wide
self.collision_sign_by = 2
demás:
self.closestpoint_by = self.ball_y
self.collision_sign_by = 3
#Defina la distancia entre el ladrillo y el punto más cercano al centro del círculo y al centro del círculo.
self.distanceb = math.sqrt(math.pow(self.closestpoint_bx-self.ball_x,2)+math.pow(self.closestpoint_by-self.ball_y,2))
# Detección de colisión de la pelota en tres situaciones: izquierda, superior media y superior derecha en el ladrillo
si self.distanceb < self.radius y self.collision_sign_by == 1 y (self.collision_sign_bx == 1 o self.collision_sign_bx == 2):
si self.collision_sign_bx == 1 y self.move_x > 0:
self.move_x = - self.move_x
self.move_y = - self.move_y
si self.collision_sign_bx == 1 y self.move_x < 0:
self.move_y = - self.move_y
si self.collision_sign_bx == 2 y self.move_x < 0:
self.move_x = - self.move_x
self.move_y = - self.move_y
si self.collision_sign_bx == 2 y self.move_x > 0:
self.move_y = - self.move_y
si self.distanceb < self.radius y self.collision_sign_by == 1 y self.collision_sign_bx == 3:
self.move_y = - self.move_y
# Detección de colisión de la pelota en tres situaciones: izquierda, centro inferior e inferior derecho debajo de los ladrillos.
si self.distanceb < self.radius y self.collision_sign_by == 2 y (self.collision_sign_bx == 1 o self.collision_sign_bx == 2):
si self.collision_sign_bx == 1 y self.move_x > 0:
self.move_x = - self.move_x
self.move_y = - self.move_y
si self.collision_sign_bx == 1 y self.move_x < 0:
self.move_y = - self.move_y
si self.collision_sign_bx == 2 y self.move_x < 0:
self.move_x = - self.move_x
self.move_y = - self.move_y
si self.collision_sign_bx == 2 y self.move_x > 0:
self.move_y = - self.move_y
si self.distanceb < self.radius y self.collision_sign_by == 2 y self.collision_sign_bx == 3:
self.move_y = - self.move_y
# Detección de colisión de la bola en el medio de los lados izquierdo y derecho del ladrillo.
si self.distanceb < self.radius y self.collision_sign_by == 3:
self.move_x = - self.move_x
clase principal (Ventana de juego, Rect, Bola, Ladrillo, Colisión, Puntuación, Ganar, GameOver):
'''Crear la clase del programa principal'''
def __init__(self,*args,**kw):
super(Principal,self).__init__(*args,**kw)
super(GameWindow,self).__init__(*args,**kw)
super(Rect,self).__init__(*args,**kw)
super(Bola,yo).__init__(*args,**kw)
super(Ladrillo,self).__init__(*args,**kw)
super(Colisión,self).__init__(*args,**kw)
super(Puntuación,self).__init__(*args,**kw)
super(Win,self).__init__(*args,**kw)
#Definir identificador de inicio del juego
signo_inicial = 0
mientras que Verdadero:
self.fondo()
self.rectmove()
self.countscore()
si self.over_sign == 1 o self.win_sign == 1:
romper
#Obtener el estado de la ventana del juego
para evento en pygame.event.get():
si evento.tipo == pygame.SALIR:
sys.salir()
si event.type == MOUSEBUTTONDOWN:
press_array = pygame.mouse.get_pressed()
si se presiona_array[0]:
signo_inicial = 1
si inicio_sign == 0:
self.ballready()
demás:
auto.movimientodebola()
self.ladrilloarreglar()
#actualizar ventana del juego
pygame.display.actualización()
#Controla la frecuencia de actualización de la ventana del juego.
tiempo.dormir(0.010)
si __nombre__ == '__principal__':
pygame.init()
pygame.font.init()
bola = principal()
3. Puntos de conocimiento 1. Herencia de múltiples clases principales
Los métodos de herencia de Python se dividen en primero en profundidad y primero en amplitud, y Python2 se divide en dos tipos: el método de herencia de búsqueda en profundidad de la clase clásica (clase A :) y el método de herencia de búsqueda en amplitud de la nueva clase (clase A (objeto):). Clase clásica de Python3 El método de herencia de las clases de nuevo estilo es consistente con el método de herencia de clases de nuevo estilo de python2, y ambos son métodos de herencia de amplitud primero.
Método de herencia de búsqueda en profundidad de clases clásicas:
como muestra la imagen
clase B(A)
clase C(A)
clase D(B,C)
(1) Si la clase D tiene un constructor, reescribe la herencia de todas las clases principales
(2) Si la clase D no tiene constructor y la clase B tiene un constructor, entonces la clase D heredará el constructor de la clase B.
(3) Si la clase D no tiene constructor y la clase B no tiene constructor, la clase D heredará el constructor de la clase A en lugar del constructor de la clase C.
(4) Si la clase D no tiene constructor, la clase B no tiene constructor y la clase A no tiene constructor, entonces la clase D heredará el constructor de la clase C.
Herencia de búsqueda en amplitud para clases de nuevo estilo:
como muestra la imagen
clase B(A)
clase C(A)
clase D(B,C)
(1) Si la clase D tiene un constructor, reescribe la herencia de todas las clases principales
(2) Si la clase D no tiene constructor y la clase B tiene un constructor, entonces la clase D heredará el constructor de la clase B.
(3) Si la clase D no tiene constructor y la clase B no tiene constructor, la clase D heredará el constructor de la clase C en lugar del constructor de la clase A.
(4) Si la clase D no tiene constructor, la clase B no tiene constructor y la clase C no tiene constructor, entonces la clase D heredará el constructor de la clase A.
A través del análisis anterior, todos deberían tener claro el orden de herencia de las clases en Python. Entonces la pregunta es, ¿qué pasa si no quiero reescribir el constructor de la clase principal y quiero los constructores tanto de la subclase como de la clase principal? ¿para tomar efecto? La solución requiere el uso de la palabra clave super, que se refiere al objeto de la clase principal directa. Puede usar super para acceder a métodos o propiedades en la clase principal que son anulados por la subclase.
clase A (objeto):
def __init__(self,*args,**kw)
clase B(A):
def __init__(self,*args,**kw)
super(B,self).__init__(*args,**kw)
clase C(A):
def __init__(self,*args,**kw)
super(C,self).__init__(*args,**kw)
clase D(B,C):
def __init__(self,*args,**kw)
super(D,self).__init__(*args,**kw)
super(B,self).__init__(*args,**kw)
2. Modelo matemático de detección de colisiones.
De hecho, los problemas de programación son, en última instancia, problemas matemáticos. Este juego implica el problema de detección de colisiones de círculos y rectángulos 2D:
Principio de detección de colisiones: encuentre el punto en el rectángulo más cercano al centro del círculo y luego determine si la distancia entre el punto y el centro del círculo es menor que el radio del círculo. Si es menor que el radio del círculo, es una colisión.
Entonces, ¿cómo encontrar el punto del rectángulo más cercano al centro del círculo? A continuación, buscamos desde las direcciones del eje x y del eje y respectivamente. Para facilitar la descripción, primero acordamos las siguientes variables:
(1) El punto del rectángulo más cercano al centro del círculo es una variable: punto más cercano = [x, y]
(2) Rectángulo recto = [x, y, l, w] esquina superior izquierda y largo, ancho
(3) Círculo círculo = [x, y, r] centro y radio
Primero el eje x:
Si el centro del círculo está en el lado izquierdo del rectángulo (si círculo_x <rect_x), entonces punto más cercano_x = rect_x.
Si el centro del círculo está en el lado derecho del rectángulo (elif círculo_x > rect_x + rect_l), entonces punto más cercano_x = rect_x + rect_l.
Si el centro del círculo está directamente encima y debajo del rectángulo (de lo contrario), entonces punto más cercano_x = círculo_x.
De manera similar, para el eje y:
Si el centro del círculo está por encima del rectángulo (si círculo_y <rect_y), entonces punto más cercano_y = rect_y.
Si el centro del círculo está debajo del rectángulo (elif círculo_y > rect_y + rect_w), entonces punto más cercano_y = rect_y + rect_w.
El centro del círculo está en los lados izquierdo y derecho del rectángulo (de lo contrario), luego punto más cercano_y = círculo_y.
Por lo tanto, mediante el método anterior, puede encontrar el punto en el rectángulo que está más cerca del centro del círculo y luego usar la "fórmula de distancia entre dos puntos" para obtener la distancia entre el "punto más cercano" y el "centro". del círculo", y finalmente súmelo al radio del círculo. relación para determinar si se ha producido una colisión.
distancia=math.sqrt(math.pow(punto más cercano_x-circulo_x,2)+math.pow(punto más cercano_y-circulo_y,2))
si distancia < círculo.r :
retorno Verdadero �C se produjo una colisión
demás :
devolver Falso �C No se produjo ninguna colisión
Lo anterior es la explicación detallada y la integración del juego de romper ladrillos Python presentado por el editor. Espero que te sea útil. Si tienes alguna pregunta, déjame un mensaje y el editor te responderá a tiempo. ¡También me gustaría agradecer a todos por su apoyo al sitio web de Script House!