Bienvenido a este tutorial sobre cómo crear un juego clásico de Ping Pong usando Python 3 y el módulo Turtle. Si eres nuevo en la programación o en la creación de juegos, ¡Worry not! Este tutorial está diseñado para principiantes y cubrirá todo lo que necesitas saber para crear tu propio juego de Pong en Python 3 (o al menos esa era la idea).
Construiremos un juego clásico de Pong, completo con paletas y una pelota. La pelota rebotará en las paredes y las paletas, y el jugador opuesto obtendrá un punto cuando la pelota salga de la pantalla. La pelota seguirá moviéndose hasta que uno de los jugadores alcance un cierto número de puntos.
Para empezar, usaremos el módulo Turtle, que es genial para principiantes porque te permite hacer algunos gráficos básicos sin tener que instalar bibliotecas adicionales. La biblioteca Turtle viene incluida con Python, por lo que no necesitas preocuparte por descargar o instalar nada adicional.
Para crear una ventana, usaremos la función turtle.Screen() y la personalizaremos con las funciones title(), bgcolor() y setup(). También usaremos la función tracer() para acelerar el juego.
Luego, crearemos un bucle de juego principal usando un bucle while True que actualiza la pantalla cada vez que se ejecuta el bucle. Este bucle se encargará de asegurarse de que el juego se ejecute sin problemas y que la pelota y las paletas se muevan correctamente.
import turtle
wn = turtle.Screen()
wn.title("Pong game")
wn.bgcolor("black")
wn.setup(width=800,height=600)
wn.tracer(0)
# Main game loop
whileTrue:
wn.update()
Ahora crearemos las paletas para nuestro juego de Pong. Comenzaremos con la paleta izquierda y crearemos un nuevo objeto Turtle con la función turtle.Turtle(). Luego personalizaremos la paleta con las funciones shape(), color() y shapesize(). Finalmente, posicionaremos la paleta con la función goto().
import turtle
import turtle
wn = turtle.Screen()
wn.title("Pong game")
wn.bgcolor("black")
wn.setup(width=800,height=600)
wn.tracer(0)
# Paddle Apaddle_a = turtle.Turtle()
paddle_a.speed(0)
paddle_a.shape("square")
paddle_a.color("white")
paddle_a.shapesize(stretch_wid=5,stretch_len=1)
paddle_a.penup()
paddle_a.goto(-350, 0)
# Paddle Bpaddle_b = turtle.Turtle()
paddle_b.speed(0)
paddle_b.shape("square")
paddle_b.color("white")
paddle_b.shapesize(stretch_wid=5,stretch_len=1)
paddle_b.penup()
paddle_b.goto(350, 0)
# Ballball = turtle.Turtle()
ball.speed(0)
ball.shape("square")
ball.color("white")
ball.penup()
ball.goto(0, 0)
# Function
defpaddle_a_up():
y = paddle_a.ycor()
y += 20
paddle_a.sety(y)
defpaddle_a_down():
y = paddle_a.ycor()
y -=20
paddle_a.sety(y)
defpaddle_b_up():
y = paddle_b.ycor()
y += 20
paddle_b.sety(y)
defpaddle_b_down():
y = paddle_b.ycor()
y -=20
paddle_b.sety(y)
# Keyboard binding
wn.listen()
wn.onkeypress(paddle_a_up, "w")
wn.onkeypress(paddle_a_down, "s")
wn.onkeypress(paddle_b_up, "Up")
wn.onkeypress(paddle_b_down, "Down")
# Main game loop
whileTrue:
wn.update()
Haremos lo mismo para la paleta derecha, pero la posicionaremos en el lado derecho de la pantalla.
# Right paddle
right_paddle = turtle.Turtle()
right_paddle.speed(0)
right_paddle.shape("square")
right_paddle.color("white")
right_paddle.shapesize(stretch_wid=6,stretch_len=2)
right_paddle.penup()
right_paddle.goto(350, 0)
Ahora que tenemos nuestras paletas, necesitamos moverlas hacia arriba y hacia abajo cuando el jugador presiona las teclas de flecha hacia arriba o hacia abajo. Para hacer esto, crearemos dos funciones: una para mover la paleta izquierda hacia arriba y hacia abajo, y otra para mover la paleta derecha hacia arriba y hacia abajo.
# Move the left paddle up
defleft_paddle_up():
y = left_paddle.ycor()
y += 20
left_paddle.sety(y)
# Move the left paddle down
defleft_paddle_down():
y = left_paddle.ycor()
y -=20
left_paddle.sety(y)
# Move the right paddle up
defright_paddle_up():
y = right_paddle.ycor()
y += 20
right_paddle.sety(y)
# Move the right paddle down
defright_paddle_down():
y = right_paddle.ycor()
y -=20
right_paddle.sety(y)
Usaremos la función onkeypress() para vincular estas funciones a las teclas de flecha hacia arriba y hacia abajo. Además, usaremos la función listen() para asegurarnos de que el programa esté “escuchando” las teclas de flecha.
# Keyboardbindingswn.listen()
wn.onkeypress(left_paddle_up, "w")
wn.onkeypress(left_paddle_down, "s")
wn.onkeypress(right_paddle_up, "Up")
wn.onkeypress(right_paddle_down, "Down")
Ahora que tenemos nuestras paletas y las teclas de flecha, necesitamos crear la pelota para nuestro juego de Pong. Comenzaremos creando un nuevo objeto Turtle y personalizándolo con las funciones shape(), color() y penup(). Luego estableceremos la dirección x e y de la pelota con las variables dx y dy. Estas variables se encargarán de mover la pelota en la pantalla.
# Ball
ball = turtle.Turtle()
ball.speed(0)
ball.shape("circle")
ball.color("white")
ball.penup()
ball.goto(0, 0)
ball.dx = 2ball.dy = 2Ahora que tenemos nuestras paletas, pelota y teclas de flecha, podemos unir todo en nuestro bucle de juego. Comenzaremos moviendo la pelota usando una variable ball.dx y ball.dy, que representarán la dirección x e y de la pelota. Luego comprobaremos las colisiones con las paredes superior e inferior y las paletas izquierda y derecha. Finalmente, actualizaremos la puntuación y reiniciaremos la pelota cuando salga de la pantalla.
import turtle
import os
wn = turtle.Screen()
wn.title("Pong")
wn.bgcolor("black")
wn.setup(width=800, height=600)
wn.tracer(0)
# Scorescore_a = 0score_b = 0# Paddle A
paddle_a = turtle.Turtle()
paddle_a.speed(0)
paddle_a.shape("square")
paddle_a.color("white")
paddle_a.shapesize(stretch_wid=5,stretch_len=1)
paddle_a.penup()
paddle_a.goto(-350, 0)
# Paddle B
paddle_b = turtle.Turtle()
paddle_b.speed(0)
paddle_b.shape("square")
paddle_b.color("white")
paddle_b.shapesize(stretch_wid=5,stretch_len=1)
paddle_b.penup()
paddle_b.goto(350, 0)
# Ballball = turtle.Turtle()
ball.speed(0)
ball.shape("square")
ball.color("white")
ball.penup()
ball.goto(0, 0)
ball.dx = 2ball.dy = 2# Pen
pen = turtle.Turtle()
pen.speed(0)
pen.shape("square")
pen.color("white")
pen.penup()
pen.hideturtle()
pen.goto(0, 260)
pen.write("Player A: 0 Player B: 0", align="center", font=("Courier", 24, "normal"))
# Functions
defpaddle_a_up():
y = paddle_a.ycor()
y += 20
paddle_a.sety(y)
defpaddle_a_down():
y = paddle_a.ycor()
y -= 20
paddle_a.sety(y)
defpaddle_b_up():
y = paddle_b.ycor()
y += 20
paddle_b.sety(y)
defpaddle_b_down():
y = paddle_b.ycor()
y -= 20
paddle_b.sety(y)
# Keyboard bindings
wn.listen()
wn.onkeypress(paddle_a_up, "w")
wn.onkeypress(paddle_a_down, "s")
wn.onkeypress(paddle_b_up, "Up")
wn.onkeypress(paddle_b_down, "Down")
# Main game loopwhileTrue:
wn.update()
# Move the ballball.setx(ball.xcor() + ball.dx)
ball.sety(ball.ycor() + ball.dy)
# Border checking# Top and bottom
if ball.ycor() > 290:
ball.sety(290)
ball.dy *= -1
os.system("afplay bounce.wav&")
elif ball.ycor() < -290:
ball.sety(-290)
ball.dy *= -1
os.system("afplay bounce.wav&")
# Left and right
if ball.xcor() > 350:
score_a += 1
pen.clear()
pen.write("Player A: {} Player B: {}".format(score_a, score_b), align="center", font=("Courier", 24, "normal"))
ball.goto(0, 0)
ball.dx *= -1
elif ball.xcor() < -350:
score_b += 1
pen.clear()
pen.write("Player A: {} Player B: {}".format(score_a, score_b), align="center", font=("Courier", 24, "normal"))
ball.goto(0, 0)
ball.dx *= -1# Paddle and ball collisions
if ball.xcor() < -340and ball.ycor() < paddle_a.ycor() + 50and ball.ycor() > paddle_a.ycor() - 50:
ball.dx *= -1
elif ball.xcor() > 340and ball.ycor() < paddle_b.ycor() + 50and ball.ycor() > paddle_b.ycor() - 50:
ball.dx *= -1Si un jugador alcanza un cierto número de puntos, el juego terminará y se imprimirá un mensaje de “game over” en la pantalla. Luego, el programa se cerrará después de unos segundos.
Una vez que hayas creado tu juego básico de Pong, hay muchas cosas que puedes hacer para mejorarlo y hacerlo más interesante. Aquí hay algunas ideas para ampliar tu juego:
En este tutorial, aprendimos cómo crear un juego de Pong usando Python 3 y el módulo Turtle. Cubrimos mucho terreno, incluyendo cómo usar cadenas, listas, bucles for y while, tuplas y cualquier otro tipo de datos de Python que nos ayudará a crear este juego. También aprendimos cómo usar el módulo Turtle para crear una ventana, paletas, una pelota y cómo moverlos usando teclas de flecha. Finalmente, aprendimos cómo comprobar colisiones y actualizar la puntuación y reiniciar la pelota cuando salga de la pantalla.
Esperamos que hayas encontrado útil este tutorial y que te haya inspirado a seguir aprendiendo Python y el desarrollo de juegos. Hay mucho más que puedes hacer con Python y el módulo Turtle, así que sigue explorando y experimentando!
