# Creating a Pong Game using Python Turtle ## Introduction

Today, we are going to create a Pong Game using Python Turtle. Pong is a well-known computer game that is similar to table tennis. The two players in this game control the two paddles on either side of the game window. To hit the moving ball, they move the paddles up and down. A player’s score rises when he or she hits the ball or when the opponent misses the hit.

To create this Python game, we will use the turtle module. To move the left and right paddles in this game, we will use the up, down, W, and S keys. As a player strikes the ball to a predefined speed level, the speed of the ball rises, as does the score. When a player misses a hit, the ball restarts from the center towards the other player, with the opponent’s score increasing.

### Step 1. Importing Turtle Module.

``````# Import the turtle library
import turtle
``````

The turtle module must be imported first. This module will be used to construct the entire game.

### Step 2. Creating the Canvas.

``````# Creating the screen with name and size
screen = turtle.Screen()
screen.title("Python Pong game by copyassignment.com ")
screen.setup(width=1000 , height=600)
``````

### Step 3. Creating left and right paddles.

``````# Creating the left paddle
#Setting its speed as zero, it moves only when key is pressed
#Setting shape, color, and size

#Setting its speed as zero, it moves only when key is pressed
#Setting shape, color, and size

The next stage is to make the left and right paddles. They are square in shape and are centered vertically on the left or right ends. Their speed is minimal. They only move when keyboard keys are pushed.

### Step 4. Next, we create a ball.

``````# Ball of circle shape
ball = turtle.Turtle()
#Setting the speed of ball to 0, it moves based on the dx and dy values
ball.speed(0)
#Setting shape, color, and size
ball.shape("circle")
ball.color("green")
ball.penup()
#Ball starts from the centre of the screen
ball.goto(0, 0)
#Setting dx and dy that decide the speed of the ball
ball.dx = 2
ball.dy = -2
``````

It’s now time to make the ball. It is circular in shape and is first situated in the center of the screen. Even though its speed is zero, it moves according to the values dx and dy. The location of the ball is updated by dx and dy every time the main game loop runs, giving the illusion of mobility.

### Step 5. Creating a scoreboard and initializing scores.

``````# Initializing the score of the two players
player1 = 0
player2 = 0
# Displaying the score
score = turtle.Turtle()
score.speed(0)
score.penup()
#Hiding the turtle to show text
score.hideturtle()
#Locating the scoreboard on top of the screen
score.goto(0, 260)
#Showing the score
score.write("Player1 : 0 Player2: 0", align="center", font=("Courier", 20, "bold"))
``````

score.write(“Player1 : 0 Player2: 0″, align=”center”, font=(“Courier”, 20, “bold”))

We then reset the scores to zero. Then, on top of the screen, construct a scoreboard to display the current scores. The write() function is used to display text on the window in this case.

### Step 6. functions to move paddles and match with keys.

``````# Function to move the left paddle up
y += 15

# Function to move the left paddle down
y -= 15

# Function to move the right paddle up
y += 15

# Function to move the right paddle down
y -= 15

# Matching the Keyboard buttons to the above functions=
screen.listen()

Now we’ll build the functions that will allow us to shift the paddles vertically. We are adjusting the y-coordinate of the paddle by 15 units to give it movement. They function as follows:

1. When you press the left arrow button on your keyboard, the movePad1Up() function is called and the left paddle moves up.

2. When you press the right arrow key on your keyboard, the movePad1Down() function is called, and the left paddle slides down.

3. When you press the up arrow button on your keyboard, the movePad2Up() function is called, and the right paddle travels up.

### Step 7. Creating the main Game.

``````#The main game
while True:
#Updating the screen every time with the new changes
screen.update()

#Moving the ball by updating the coordinates
ball.setx(ball.xcor()+ball.dx)
ball.sety(ball.ycor()+ball.dy)

# Checking if ball hits the top of the screen
if ball.ycor() > 280:
ball.sety(280)
ball.dy *= -1 #Bouncing the ball

# Checking if ball hits the bottom of the screen
if ball.ycor() < -280:
ball.sety(-280)
ball.dy *= -1#Bouncing the ball

#Checking if the ball hits the left or right walls, the player missed the hit
if ball.xcor() > 480 or ball.xcor() < -480:
if(ball.xcor() <-480):
player2 += 1 #Increasing the score of right player if left player missed
else:
player1 += 1 #Increasing the score of left player if right player missed
#Starting ball again from center towards the opposite direction
ball.goto(0, 0)
ball.dx *= -1
ball.dy *= -1

#Updating score in the scoreboard
score.clear()
score.write("Player1 : {} Player2: {}".format(player1, player2), align="center", font=("Courier", 20, "bold"))

#Checking if the left player hit the ball
if (ball.xcor() < -360 and ball.xcor() > -370) and (paddle1.ycor() + 50 > ball.ycor() > paddle1.ycor() - 50):
#Increasing score of left player and updating score board
player1 += 1
score.clear()
score.write("Player A: {} Player B: {}".format(player1, player2), align="center", font=("Courier", 20, "bold"))
ball.setx(-360)

#Increasing speed of the ball with the limit 7
if(ball.dy>0 and ball.dy<5): #If dy is positive increasing dy
ball.dy+=0.5
elif(ball.dy<0 and ball.dy>-5): #else if dy is negative decreasing dy
ball.dy-=0.5

if(ball.dx>0 and ball.dx<5):#If dx is positive increasing dx
ball.dx+=0.5
elif(ball.dx<0 and ball.dx>-5): #else if dx is negative decreasing dx
ball.dx-=0.5

#Changing the direction of ball towards the right player
ball.dx *=-1

#Checking if the right player hit the ball
if (ball.xcor() > 360 and ball.xcor() < 370) and (paddle2.ycor() + 50 > ball.ycor() > paddle2.ycor() - 50):
#Increasing score of right player and updating scoreboard
player2 += 1
score.clear()
score.write("Player A: {} Player B: {}".format(player1, player2), align="center", font=("Courier", 20, "bold"))
ball.setx(360)

#Increasing speed of the ball with the limit 7
if(ball.dy>0 and ball.dy<7):#If dy is positive increasing dy
ball.dy+=1
elif(ball.dy<0 and ball.dy>-7):#else if dy is negative decreasing dy
ball.dy-=1

if(ball.dx>0 and ball.dx<7):#If dx is positive increasing dx
ball.dx+=1
elif(ball.dx<0 and ball.dx>-7): #else if dx is negative decreasing dx
ball.dx-=1

#Changing the direction of ball towards the left player
ball.dx*=-1
``````

Finally, we’ve arrived to write the core game’s code. We write it in a while loop that continues indefinitely until the window is closed.

• We begin by updating the screen. The ball is then moved by updating the dx and dy coordinates.
• We bounce the ball by changing the sign of dy after checking if it touches the top and bottom walls.
• We know that if one of the players fails to hit the ball, it will bounce off the left or right barriers. As a result, we look to see if the ball strikes the left or right walls. Change the opponent’s score and refresh the scoreboard.
• Start the ball in the opposite direction from the middle of the screen.
• Finally, we look to see if any of the paddles have made contact with the ball. Update the scoreboard and raise the score. Increase the speed while staying inside the speed limit. 7 Change the direction of the ball’s dx, causing it to move towards the opposing player.

## Complete code to Create a Pong Game using Python Turtle

```# Import required library
import turtle

# Create screen
sc = turtle.Screen()
sc.title("Pong game")
sc.bgcolor("Black")
sc.setup(width=1000, height=600)

# Ball of circle shape
hit_ball = turtle.Turtle()
hit_ball.speed(40)
hit_ball.shape("circle")
hit_ball.color("pink")
hit_ball.penup()
hit_ball.goto(0, 0)
hit_ball.dx = 5
hit_ball.dy = -5

# Initialize the score
left_player = 0
right_player = 0

# Displays the score
sketch = turtle.Turtle()
sketch.speed(0)
sketch.color("blue")
sketch.penup()
sketch.hideturtle()
sketch.goto(0, 260)
sketch.write("Left_player : 0 Right_player: 0",align="center", font=("Courier", 24, "normal"))

# Functions to move paddle vertically
y += 20

y -= 20

y += 20

y -= 20

# Keyboard bindings
sc.listen()

while True:
sc.update()

hit_ball.setx(hit_ball.xcor()+hit_ball.dx)
hit_ball.sety(hit_ball.ycor()+hit_ball.dy)

# Checking borders
if hit_ball.ycor() > 280:
hit_ball.sety(280)
hit_ball.dy *= -1

if hit_ball.ycor() < -280:
hit_ball.sety(-280)
hit_ball.dy *= -1

if hit_ball.xcor() > 500:
hit_ball.goto(0, 0)
hit_ball.dy *= -1
left_player += 1
sketch.clear()
sketch.write("Left_player : {} Right_player: {}".format(left_player, right_player), align="center",font=("Courier", 24, "normal"))

if hit_ball.xcor() < -500:
hit_ball.goto(0, 0)
hit_ball.dy *= -1
right_player += 1
sketch.clear()
sketch.write("Left_player : {} Right_player: {}".format(left_player, right_player), align="center",font=("Courier", 24, "normal"))

if (hit_ball.xcor() > 360 and hit_ball.xcor() < 370) and (hit_ball.ycor() < right_pad.ycor()+40 and hit_ball.ycor() > right_pad.ycor()-40):
hit_ball.setx(360)
hit_ball.dx*=-1

hit_ball.setx(-360)
hit_ball.dx*=-1
```

## Output:

We successfully developed the Pong Game using Python Turtle We learned how to make forms for blocks and balls, as well as how to modify the pace and refresh the screen. 