Cómo programar un juego en Python con Pygame

Esta es una introducción a Pygame para las personas que ya conocen Python. Este artículo te enseñará los pasos para construir un juego simple que tenga al jugador esquivando bolas que botan.

Parte uno de ocho:
Instalando Pygame

1. 1 Descargar Pygame. Encuéntrelo para su plataforma en http://www.pygame.org/download.shtml.
2. 2Ejecuta el instalador.
3. 3 Verifique que la instalación funcionó. Abra una terminal de Python. Escriba "importar pygame". Si no ve ningún error, Pygame se instaló correctamente.

    importar pygame 

Parte dos de ocho:
Configurando una Ventana Básica

1. 1Abra un nuevo archivo.
2. 2 Importar Pygame. Pygame es una biblioteca que proporciona acceso a funciones gráficas. Si desea obtener más información sobre cómo funcionan estas funciones, puede buscarlas en el sitio web de Pygame. https://www.pygame.org/docs/

    importar pygame de Pygame.lugareños importar * 

3. 3 Establezca la resolución de la ventana. Harás una variable global para la resolución de la pantalla, por lo que podrás hacer referencia a ella en varias partes del juego. También es fácil de encontrar en la parte superior del archivo para poder cambiarlo más tarde. Para proyectos avanzados, poner esta información en un archivo separado sería una mejor idea.

    resolución = (400,300) 

4. 4 Definir algunos colores Los colores en pygame son (RBGA que varían en valores entre 0 y 255. El valor alfa (A) es opcional pero los otros colores (rojo, azul y verde son obligatorios).

    blanco = (255,255,255) negro = (0,0,0) rojo = (255,0,0) 

5. 5 Inicializa la pantalla. Use la variable de resolución que se definió anteriormente.

    pantalla = Pygame.monitor.modo de ajuste(resolución) 

6. 6 Haz un bucle de juego. Repite ciertas acciones en cada cuadro de nuestro juego. Haz un ciclo que siempre se repetirá para recorrer todas estas acciones.

    mientras Cierto: 

7. 7 Colorea la pantalla.

    pantalla.llenar(blanco) 

8. 8 Visualiza la pantalla. Si ejecuta el programa, la pantalla se pondrá blanca y luego el programa se bloqueará. Esto se debe a que el sistema operativo está enviando eventos al juego y el juego no está haciendo nada con ellos. Una vez que el juego recibe demasiados eventos no controlados, se bloqueará.

    mientras Cierto:… pygame.monitor.dar la vuelta() 

9. 9 Manejar eventos. Obtenga una lista de todos los eventos que ocurrieron en cada marco. Solo te interesará un evento, el evento de dejar de fumar. Esto ocurre cuando el usuario cierra la ventana del juego. Esto también evitará que nuestro programa falle debido a demasiados eventos.

    mientras Cierto:… para evento en Pygame.evento.obtener(): Si evento.tipo == SALIR: pygame.dejar() 

10. 10 ¡Pruébalo! Así es como debería verse el código ahora:

     importar pygame de Pygame.lugareños importar * resolución = (400,300) blanco = (255,255,255) negro = (0,0,0) rojo = (255,0,0) pantalla = Pygame.monitor.modo de ajuste(resolución) mientras Cierto: pantallallenar(blanco) Pygame.monitor.dar la vuelta() para evento en Pygame.evento.obtener(): Si evento.tipo == SALIR: pygame.dejar() 

Parte tres de ocho:
Hacer un objeto de juego

1. 1 Crea una nueva clase y constructor. Establezca todas las propiedades del objeto. También está proporcionando valores predeterminados para todas las propiedades.

    clase Pelota: def __en eso__(yo, xPos = resolución[0] / 2, yPos = resolución[1] / 2, xVel = 1, yVel = 1, rad = 15): yo.X = xPos yo.y = yPos yo.dx = xVel yo.dy = yVel yo.radio = rad yo.tipo = "pelota" 

2. 2 Definir cómo dibujar el objeto. Utilice las propiedades que se definieron en el constructor para dibujar la bola como un círculo y para pasar una superficie a la función para dibujar el objeto. La superficie será el objeto de pantalla que se creó utilizando la resolución anterior.

    def dibujar(yo, superficie): pygamedibujar.circulo(superficie, negro, (yo.X, yo.y), yo.radio) 

3. 3 Haga una instancia de la clase y diga al bucle del juego que dibuje la bola en cada ciclo.

    pelota = Pelota() mientras Cierto:… pelota.dibujar(pantalla) 

4. 4 Haz que el objeto se mueva. Crea una función que actualizará la posición del objeto. Llame a esta función en cada ciclo de juego.

    clase Pelota:… def actualizar(yo): yo.X += yo.dx yo.y += yo.dy 

5. 5 Limite la velocidad de cuadros. La pelota se moverá muy rápido porque el bucle del juego se ejecuta cientos de veces por segundo. Use el reloj de Pygame para limitar la velocidad de cuadros a 60 fps.

    reloj = Pygame.hora.Reloj() mientras Cierto:… reloj.garrapata(60) 

6. 6 Mantenga la pelota en la pantalla. Agregue controles en la función de actualización para invertir la dirección de la bola si golpea uno de los bordes de la pantalla.

    clase Pelota:… def actualizar(yo):… Si (yo.X <= 0 o yo.X >= resolución[0]): yo.dx *= -1 Si (yo.y <= 0 o yo.y >= resolución[1]): yo.dy *= -1 

7. 7 ¡Pruébalo! Así es como debería verse el código ahora:

    importar pygame de Pygame.lugareños importar * resolución = (400,300) blanco = (255,255,255) negro = (0,0,0) rojo = (255,0,0) pantalla = Pygame.monitor.modo de ajuste(resolución) clase Pelota: def __en eso__(yo, xPos = resolución[0] / 2, yPos = resolución[1] / 2, xVel = 1, yVel = 1, rad = 15): yo.X = xPos yo.y = yPos yo.dx = xVel yo.dy = yVel yo.radio = rad yo.tipo = "pelota" def dibujar(yo, superficie): pygamedibujar.circulo(superficie, negro, (yo.X, yo.y), yo.radio) def actualizar(yo): yo.X += yo.dx yo.y += yo.dy Si (yo.X <= 0 o yo.X >= resolución[0]): yo.dx *= -1 Si (yo.y <= 0 o yo.y >= resolución[1]): yo.dy *= -1 pelota = Pelota() reloj = Pygame.hora.Reloj() mientras Cierto: pantallallenar(blanco) pelota.dibujar(pantalla) pelota.actualizar() Pygame.monitor.dar la vuelta() reloj.garrapata(60) para evento en Pygame.evento.obtener(): Si evento.tipo == SALIR: pygame.dejar() 

Parte cuatro de ocho:
Organizando el juego

1. 1 Usa clases para organizar todo. El juego se va a volver más complicado. Use técnicas orientadas a objetos para organizar su código.
2. 2 Haz que el juego se vuelva una clase. Como nuestro juego ahora contiene datos que incluyen los objetos y funciones de tu juego, tiene sentido convertir tu bucle de juego en una clase.

    clase juego(): 

3. 3 Agrega un constructor. Aquí creará una instancia de algunos objetos del juego, creará nuestra pantalla y reloj e iniciará Pygame. Pygame necesita ser inicializado para usar ciertas características como texto o sonido.

    clase juego(): def __en eso__(yo): pygameen eso() yo.pantalla = Pygame.monitor.modo de ajuste(resolución) yo.reloj = Pygame.hora.Reloj() 

4. 4 Manejar eventos en una función.

    clase juego():… def handleEvents(yo): para evento en Pygame.evento.obtener(): Si evento.tipo == SALIR: pygame.dejar() 

5. 5 Haz que el bucle del juego sea una función. Llame a la función de manejo de eventos en cada ciclo.

    clase juego():… def correr(yo): mientras Cierto: yo.handleEvents() yo.pantalla.llenar(blanco) yo.reloj.garrapata(60) Pygame.monitor.dar la vuelta() 

6. 6 Maneja múltiples objetos del juego. En este momento, este código tiene que llamar a dibujar y actualizar en nuestro objeto cada fotograma. Esto se ensuciaría si tuviera muchos objetos. Agreguemos nuestro objeto a una matriz y luego actualice y dibuje todos los objetos en la matriz en cada ciclo. Ahora puede agregar fácilmente otro objeto y darle una posición inicial diferente.

    clase juego(): def __en eso__(yo):… yo.gameObjects = [] yo.gameObjects.adjuntar(Pelota()) yo.gameObjects.adjuntar(Pelota(100))… def correr(yo): mientras Cierto: yo.handleEvents() para gameObj en yo.gameObjects: gameObj.actualizar() yo.pantalla.llenar(blanco) para gameObj en yo.gameObjects: gameObj.dibujar(yo.pantalla) yo.reloj.garrapata(60) Pygame.monitor.dar la vuelta() 

7. 7 ¡Pruébalo! Así es como debería verse el código ahora:

    importar pygame de Pygame.lugareños importar * resolución = (400,300) blanco = (255,255,255) negro = (0,0,0) rojo = (255,0,0) pantalla = Pygame.monitor.modo de ajuste(resolución) clase Pelota: def __en eso__(yo, xPos = resolución[0] / 2, yPos = resolución[1] / 2, xVel = 1, yVel = 1, rad = 15): yo.X = xPos yo.y = yPos yo.dx = xVel yo.dy = yVel yo.radio = rad yo.tipo = "pelota" def dibujar(yo, superficie): pygamedibujar.circulo(superficie, negro, (yo.X, yo.y), yo.radio) def actualizar(yo): yo.X += yo.dx yo.y += yo.dy Si (yo.X <= 0 o yo.X >= resolución[0]): yo.dx *= -1 Si (yo.y <= 0 o yo.y >= resolución[1]): yo.dy *= -1 clase juego(): def __en eso__(yo): pygameen eso() yo.pantalla = Pygame.monitor.modo de ajuste(resolución) yo.reloj = Pygame.hora.Reloj() yo.gameObjects = [] yo.gameObjects.adjuntar(Pelota()) yo.gameObjects.adjuntar(Pelota(100)) def handleEvents(yo): para evento en Pygame.evento.obtener(): Si evento.tipo == SALIR: pygame.dejar() def correr(yo): mientras Cierto: yo.handleEvents() para gameObj en yo.gameObjects: gameObj.actualizar() yo.pantalla.llenar(blanco) para gameObj en yo.gameObjects: gameObj.dibujar(yo.pantalla) yo.reloj.garrapata(60) Pygame.monitor.dar la vuelta() juego().correr() 

Parte cinco de ocho:
Agregar un objeto de jugador

1. 1 Haz una clase de jugador y un constructor. Vas a hacer otro círculo controlado por el mouse. Inicializa los valores en el constructor. El radio es el único valor importante.

    clase Jugador: def __en eso__(yo, rad = 20): yo.X = 0 yo.y = 0 yo.radio = rad 

2. 2 Definir cómo dibujar el objeto del jugador. Va a ser de la misma manera que dibujaste los otros objetos del juego.

    clase Jugador:… def dibujar(yo, superficie): pygamedibujar.circulo(superficie, rojo, (yo.X, yo.y), yo.radio) 

3. 3 Agregue el control del mouse para el objeto del jugador. En cada cuadro, verifique la ubicación del mouse y configure la ubicación de los objetos de los jugadores en ese punto.

    clase Jugador:… def actualizar(yo): cordón = Pygame.ratón.get_pos() yo.X = cable[0] yo.y = cable[1] 

4. 4 Agrega un objeto de jugador a gameObjects. Crea una nueva instancia de jugador y agrégala a la lista.

    clase juego(): def __en eso__(yo):… yo.gameObjects.adjuntar(Jugador()) 

5. 5 ¡Pruébalo! Así es como debería verse el código ahora:

    importar pygame de Pygame.lugareños importar * resolución = (400,300) blanco = (255,255,255) negro = (0,0,0) rojo = (255,0,0) pantalla = Pygame.monitor.modo de ajuste(resolución) clase Pelota: def __en eso__(yo, xPos = resolución[0] / 2, yPos = resolución[1] / 2, xVel = 1, yVel = 1, rad = 15): yo.X = xPos yo.y = yPos yo.dx = xVel yo.dy = yVel yo.radio = rad yo.tipo = "pelota" def dibujar(yo, superficie): pygamedibujar.circulo(superficie, negro, (yo.X, yo.y), yo.radio) def actualizar(yo): yo.X += yo.dx yo.y += yo.dy Si (yo.X <= 0 o yo.X >= resolución[0]): yo.dx *= -1 Si (yo.y <= 0 o yo.y >= resolución[1]): yo.dy *= -1 clase Jugador: def __en eso__(yo, rad = 20): yo.X = 0 yo.y = 0 yo.radio = rad yo.tipo = "jugador" def dibujar(yo, superficie): pygamedibujar.circulo(superficie, rojo, (yo.X, yo.y), yo.radio) def actualizar(yo): cordón = Pygame.ratón.get_pos() yo.X = cable[0] yo.y = cable[1] clase juego(): def __en eso__(yo): pygameen eso() yo.pantalla = Pygame.monitor.modo de ajuste(resolución) yo.reloj = Pygame.hora.Reloj() yo.gameObjects = [] yo.gameObjects.adjuntar(Jugador()) yo.gameObjects.adjuntar(Pelota()) yo.gameObjects.adjuntar(Pelota(100)) def handleEvents(yo): para evento en Pygame.evento.obtener(): Si evento.tipo == SALIR: pygame.dejar() def correr(yo): mientras Cierto: yo.handleEvents() para gameObj en yo.gameObjects: gameObj.actualizar() yo.pantalla.llenar(blanco) para gameObj en yo.gameObjects: gameObj.dibujar(yo.pantalla) yo.reloj.garrapata(60) Pygame.monitor.dar la vuelta() juego().correr() 

Parte seis de ocho:
Hacer que los objetos interactúen con el reproductor

1. 1 Cambiar las funciones de actualización. Para que los objetos interactúen, necesitarán tener acceso el uno al otro. Agreguemos otro parámetro a la Actualización para pasar en la lista gameObjects. Tendrás que agregarlo tanto al objeto jugador como a los objetos Ball. Si tiene muchos objetos de juego, la herencia podría ayudarlo a mantener todas las firmas de métodos iguales.

    clase Pelota:… def actualizar(yo, gameObjects):… clase Jugador:… def actualizar(yo, gameObjects): 

2. 2 Verifique si hay colisiones entre el jugador y las bolas. Repasa todos los objetos del juego y comprueba si el tipo de objetos es bola. Luego use los radios de los dos objetos y la fórmula de distancia para verificar si están colisionando. Los círculos son realmente fáciles de verificar las colisiones. Esta es la razón principal por la que no usaste otra forma para este juego.

    clase Jugador:… def actualizar(yo, gameObjects):… para gameObj en gameObjects: Si juegoObj.tipo == "pelota": Si (juegoObj.X - yo.X)**2 + (juegoObj.y - yo.y)**2 <= (juegoObj.radio + yo.radio)**2: 

3. 3 Termina el juego si el jugador recibe "golpe". Solo salgamos del juego por ahora.

    Si (juegoObj.X - yo.X)**2 + (juegoObj.y - yo.y)**2 <= (juegoObj.radio + yo.radio)**2: pygamedejar() 

4. 4 ¡Pruébalo! Así es como debería verse el código ahora:

    importar pygame de Pygame.lugareños importar * resolución = (400, 300) blanco = (255,255,255) negro = (0,0,0) rojo = (255,0,0) pantalla = Pygame.monitor.modo de ajuste(resolución) clase Pelota: def __en eso__(yo, xPos = resolución[0] / 2, yPos = resolución[1] / 2, xVel = 1, yVel = 1, rad = 15): yo.X = xPos yo.y = yPos yo.dx = xVel yo.dy = yVel yo.radio = rad yo.tipo = "pelota" def dibujar(yo, superficie): pygamedibujar.circulo(superficie, negro, (yo.X, yo.y), yo.radio) def actualizar(yo, gameObjects): yo.X += yo.dx yo.y += yo.dy Si (yo.X <= 0 o yo.X >= resolución[0]): yo.dx *= -1 Si (yo.y <= 0 o yo.y >= resolución[1]): yo.dy *= -1 clase Jugador: def __en eso__(yo, rad = 20): yo.X = 0 yo.y = 0 yo.radio = rad yo.tipo = "jugador" def dibujar(yo, superficie): pygamedibujar.circulo(superficie, rojo, (yo.X, yo.y), yo.radio) def actualizar(yo, gameObjects): cordón = Pygame.ratón.get_pos() yo.X = cable[0] yo.y = cable[1] para gameObj en gameObjects: Si juegoObj.tipo == "pelota": Si (juegoObj.X - yo.X)**2 + (juegoObj.y - yo.y)**2 <= (juegoObj.radio + yo.radio)**2: pygamedejar() clase juego(): def __en eso__(yo): pygameen eso() yo.pantalla = Pygame.monitor.modo de ajuste(resolución) yo.reloj = Pygame.hora.Reloj() yo.gameObjects = [] yo.gameObjects.adjuntar(Jugador()) yo.gameObjects.adjuntar(Pelota()) yo.gameObjects.adjuntar(Pelota(100)) def handleEvents(yo): para evento en Pygame.evento.obtener(): Si evento.tipo == SALIR: pygame.dejar() def correr(yo): mientras Cierto: yo.handleEvents() para gameObj en yo.gameObjects: gameObj.actualizar(yo.gameObjects) yo.pantalla.llenar(blanco) para gameObj en yo.gameObjects: gameObj.dibujar(yo.pantalla) yo.reloj.garrapata(60) Pygame.monitor.dar la vuelta() juego().correr() 

Parte Siete de Ocho:
Agregar un controlador de juego para crear objetos

1. 1 Crea una clase de controlador de juegos. Los controladores del juego son responsables de "ejecutar" el juego. Es diferente de nuestra clase de juego que es responsable de dibujar y actualizar todos nuestros objetos. El controlador agregará periódicamente otra bola a la pantalla para hacer el juego más difícil. Agregue un constructor e inicialice algunos valores básicos. El intervalo será el tiempo antes de que se agregue otra bola.

    clase Control de juego: def __en eso__(yo, intervalo = 5): yo.enterrar = intervalo yo.siguiente = Pygame.hora.get_ticks() + (2 * 1000) yo.tipo = "control de juego" 

2. 2 Agrega la función de actualización. Esto verificará cuánto tiempo ha pasado desde que se agregó una bola o desde el inicio del juego. Si el tiempo es más que el intervalo, restablecerá la hora y agregará una pelota.

    clase Control de juego:… def actualizar(yo, gameObjects): Si yo.siguiente < Pygame.hora.get_ticks(): yo.siguiente = Pygame.hora.get_ticks() + (yo.enterrar * 1000) gameObjects.adjuntar(Pelota()) 

3. 3 Dale a las bolas velocidades aleatorias. Tendrá que usar números aleatorios para hacer que el juego sea diferente cada vez. Sin embargo, las velocidades de las bolas ahora son un número de coma flotante en lugar de un número entero.

    clase Control de juego:… def actualizar(yo, gameObjects): Si yo.siguiente < Pygame.hora.get_ticks(): yo.siguiente = Pygame.hora.get_ticks() + (yo.enterrar * 1000) gameObjects.adjuntar(Pelota(xVel=aleatorio()*2, yVel=aleatorio()*2)) 

4. 4 Arregla la función de dibujar. La función de dibujo no aceptará flotadores. Vamos a convertir la posición de la bola a números enteros antes de que se dibujen las bolas.

    clase Pelota:… def dibujar(yo, superficie): pygamedibujar.circulo(superficie, negro, (En t(yo.X), En t(yo.y)), yo.radio) 

5. 5 Definir un método de sorteo para el controlador del juego. Como es un objeto de juego, el lazo principal intentará dibujarlo. Deberá definir una función de dibujo que no haga nada para que el juego no se bloquee.

    clase Control de juego:… def dibujar(yo, pantalla): pasar 

6. 6 Agregue el controlador del juego a gameObjects y elimine las 2 bolas. El juego debería generar una bola cada cinco segundos.

    clase juego(): def __en eso__(yo):… yo.gameObjects = [] yo.gameObjects.adjuntar(Control de juego()) yo.gameObjects.adjuntar(Jugador()) 

7. 7 ¡Pruébalo! Así es como debería verse el código ahora:

    importar pygame de aleatorio importar aleatorio de Pygame.lugareños importar * resolución = (400,300) blanco = (255,255,255) negro = (0,0,0) rojo = (255,0,0) pantalla = Pygame.monitor.modo de ajuste(resolución) clase Pelota: def __en eso__(yo, xPos = resolución[0] / 2, yPos = resolución[1] / 2, xVel = 1, yVel = 1, rad = 15): yo.X = xPos yo.y = yPos yo.dx = xVel yo.dy = yVel yo.radio = rad yo.tipo = "pelota" def dibujar(yo, superficie): pygamedibujar.circulo(superficie, negro, (En t(yo.X), En t(yo.y)), yo.radio) def actualizar(yo, gameObjects): yo.X += yo.dx yo.y += yo.dy Si (yo.X <= 0 o yo.X >= resolución[0]): yo.dx *= -1 Si (yo.y <= 0 o yo.y >= resolución[1]): yo.dy *= -1 clase Jugador: def __en eso__(yo, rad = 20): yo.X = 0 yo.y = 0 yo.radio = rad yo.tipo = "jugador" def dibujar(yo, superficie): pygamedibujar.circulo(superficie, rojo, (yo.X, yo.y), yo.radio) def actualizar(yo, gameObjects): cordón = Pygame.ratón.get_pos() yo.X = cable[0] yo.y = cable[1] para gameObj en gameObjects: Si juegoObj.tipo == "pelota": Si (juegoObj.X - yo.X)**2 + (juegoObj.y - yo.y)**2 <= (juegoObj.radio + yo.radio)**2: pygamedejar() clase Control de juego: def __en eso__(yo, intervalo = 5): yo.enterrar = intervalo yo.siguiente = Pygame.hora.get_ticks() + (2 * 1000) yo.tipo = "control de juego" def actualizar(yo, gameObjects): Si yo.siguiente < Pygame.hora.get_ticks(): yo.siguiente = Pygame.hora.get_ticks() + (yo.enterrar * 1000) gameObjects.adjuntar(Pelota(xVel=aleatorio()*2, yVel=aleatorio()*2)) def dibujar(yo, pantalla): pasar clase juego(): def __en eso__(yo): pygameen eso() yo.pantalla = Pygame.monitor.modo de ajuste(resolución) yo.reloj = Pygame.hora.Reloj() yo.gameObjects = [] yo.gameObjects.adjuntar(Control de juego()) yo.gameObjects.adjuntar(Jugador()) def handleEvents(yo): para evento en Pygame.evento.obtener(): Si evento.tipo == SALIR: pygame.dejar() def correr(yo): mientras Cierto: yo.handleEvents() para gameObj en yo.gameObjects: gameObj.actualizar(yo.gameObjects) yo.pantalla.llenar(blanco) para gameObj en yo.gameObjects: gameObj.dibujar(yo.pantalla) yo.reloj.garrapata(60) Pygame.monitor.dar la vuelta() juego().correr() 

Parte ocho de ocho:
Agregar un puntaje y un juego terminado

1. 1 Agrega un puntaje a la clase de controlador del juego. Crea un objeto de fuente y una variable de puntuación. Dibujará la fuente en cada cuadro para mostrar el puntaje y aumentará el puntaje en cada fotograma en la actualización.

    clase Control de juego: def __en eso__(yo, intervalo = 5):… yo.Puntuación = 0 yo.scoreText = Pygame.fuente.Fuente(Ninguna, 12) def actualizar(yo, gameObjects):… yo.Puntuación += 1 def dibujar(yo, pantalla): pantallablit(yo.scoreText.hacer(str(yo.Puntuación), Cierto, negro), (5,5)) 

2. 2 Modificar cómo termina el juego. Vamos a deshacernos de la renuncia cuando el jugador detecta una colisión. En cambio, establecerás una variable en el jugador que el juego puede verificar. Cuando se configura gameOver, deja de actualizar objetos. Esto congelará todo en su lugar para que el jugador pueda ver lo que sucedió y verificar su puntaje. Tenga en cuenta que los objetos todavía se están dibujando, simplemente no se actualizan.

    clase Jugador: def __en eso__(yo, rad = 20):… yo.juego terminado = Falso def actualizar(yo, gameObjects):… para gameObj en gameObjects: Si juegoObj.tipo == "pelota": Si (juegoObj.X - yo.X)**2 + (juegoObj.y - yo.y)**2 <= (juegoObj.radio + yo.radio)**2: yo.juego terminado = Cierto clase juego(): def __en eso__(yo):… yo.juego terminado = Falso def correr(yo): mientras Cierto: yo.handleEvents() Si no yo.juego terminado: para gameObj en yo.gameObjects: gameObj.actualizar(yo.gameObjects) Si juegoObj.tipo == "jugador": yo.juego terminado = juegoObj.juego terminado 

3. 3 ¡Pruébalo! Así es como debería verse el código final ahora:

    importar pygame de aleatorio importar aleatorio de Pygame.lugareños importar * resolución = (400,300) blanco = (255,255,255) negro = (0,0,0) rojo = (255,0,0) pantalla = Pygame.monitor.modo de ajuste(resolución) clase Pelota: def __en eso__(yo, xPos = resolución[0] / 2, yPos = resolución[1] / 2, xVel = 1, yVel = 1, rad = 15): yo.X = xPos yo.y = yPos yo.dx = xVel yo.dy = yVel yo.radio = rad yo.tipo = "pelota" def dibujar(yo, superficie): pygamedibujar.circulo(superficie, negro, (En t(yo.X), En t(yo.y)), yo.radio) def actualizar(yo, gameObjects): yo.X += yo.dx yo.y += yo.dy Si (yo.X <= 0 o yo.X >= resolución[0]): yo.dx *= -1 Si (yo.y <= 0 o yo.y >= resolución[1]): yo.dy *= -1 clase Jugador: def __en eso__(yo, rad = 20): yo.X = 0 yo.y = 0 yo.radio = rad yo.tipo = "jugador" yo.juego terminado = Falso def dibujar(yo, superficie): pygamedibujar.circulo(superficie, rojo, (yo.X, yo.y), yo.radio) def actualizar(yo, gameObjects): cordón = Pygame.ratón.get_pos() yo.X = cable[0] yo.y = cable[1] para gameObj en gameObjects: Si juegoObj.tipo == "pelota": Si (juegoObj.X - yo.X)**2 + (juegoObj.y - yo.y)**2 <= (juegoObj.radio + yo.radio)**2: yo.juego terminado = Cierto clase Control de juego: def __en eso__(yo, intervalo = 5): yo.enterrar = intervalo yo.siguiente = Pygame.hora.get_ticks() + (2 * 1000) yo.tipo = "control de juego" yo.Puntuación = 0 yo.scoreText = Pygame.fuente.Fuente(Ninguna, 12) def actualizar(yo, gameObjects): Si yo.siguiente < Pygame.hora.get_ticks(): yo.siguiente = Pygame.hora.get_ticks() + (yo.enterrar * 1000) gameObjects.adjuntar(Pelota(xVel=aleatorio()*2, yVel=aleatorio()*2)) yo.Puntuación += 1 def dibujar(yo, pantalla): pantallablit(yo.scoreText.hacer(str(yo.Puntuación), Cierto, negro), (5,5)) clase juego(): def __en eso__(yo): pygameen eso() yo.pantalla = Pygame.monitor.modo de ajuste(resolución) yo.reloj = Pygame.hora.Reloj() yo.gameObjects = [] yo.gameObjects.adjuntar(Control de juego()) yo.gameObjects.adjuntar(Jugador()) yo.juego terminado = Falso def handleEvents(yo): para evento en Pygame.evento.obtener(): Si evento.tipo == SALIR: pygame.dejar() def correr(yo): mientras Cierto: yo.handleEvents() Si no yo.juego terminado: para gameObj en yo.gameObjects: gameObj.actualizar(yo.gameObjects) Si juegoObj.tipo == "jugador": yo.juego terminado = juegoObj.juego terminado yo.pantalla.llenar(blanco) para gameObj en yo.gameObjects: gameObj.dibujar(yo.pantalla) yo.reloj.garrapata(60) Pygame.monitor.dar la vuelta() juego().correr()