Coding the Pong Recreation from Scratch in Python

is likely one of the earliest and most iconic video games within the historical past of digital leisure. In its basic kind, the sport simulates a desk tennis match with two paddles that transfer vertically throughout the display screen to hit a bouncing ball. Every of the participant controls a paddle and has to bounce the ball again to the opposite participant, or else they offer some extent to the alternative participant.

The historical past of the sport is considerably attention-grabbing. The Pong recreation was created and written by Allan Alcom as a check when he was recruited by Atari. This recreation then grew to become an enormous success, promoting a great deal of machines the world over’s pubs and bars, and it so occurred that the machines would choke with the a great deal of cash individuals would put in, in order that ultimately the bars and pubs’ homeowners needed to name Atari to repair their machines!

On this tutorial, we are going to use Python’s Object Oriented Programming method to code the Pong recreation. That is an intermediate-level Python programming tutorial that requires one to have a preliminary information of Python fundamentals: record, …

Understanding the Venture

There are a variety of how we are able to code this recreation. We will use the simple technique and do every job step-by-step with the mandatory repetitions, or we are able to use Python’s Object Oriented Programming method to escapre the repetition and have a neat and arranged code. We’ll choose the second possibility as this may make the sport’s program extra systematic and fewer messy!

We’ll use Python’s Turtle module for the visible recreation improvement. The turtle module is a built-in performance that enables one to visulalize code in a simple method. It mainly consists of a turtle that’s drawing shapes and contours because it strikes throughout the display screen in line with the coder’s directions. It’s a highly effective software to create beginner-level video games, and get instantaneous suggestions by a visible display screen.

The next are the important thing duties that we are going to method in an orderly method:

1. Creating the Recreation Display screen – that is the display screen on which the Pong recreation shall be displayed
2. Creating the Paddle & Paddle Class – that is the code that can create a paddle on display screen, and configure its actions, which we are going to convert to a category as a blueprint to create 2 paddles, one on the left aspect and the opposite on the proper aspect
3. Creating the Ball Class and Objects – persevering with with the OOP method, we are going to create a generic ball class after which create the ball that can transfer throughout the display screen, we can even outline its related strategies
4. Detecting Collision of Ball with High/Backside Wall -this is the piece of code that can detect collision with the higher and decrease partitions, and if collision happens, it’s going to make the ball bounce throughout the y-axis
5. Detecting Collision with Paddle – that is the piece of code that can detect whether or not the ball collides with the paddle. If sure, it’s going to make the ball bounce; else, if the paddles misses the ball, it’s going to give a rating to the alternative participant and restart the sport with the ball on the centre.
6. Creating the Scoreboard Class and Object – that is the piece of code that features the creation of the Scoreboard class in a separate Python file and the creation of its object in the principle recreation file.

Creating the Recreation Display screen

The primary job is to create the sport display screen. This display screen shall be rectangular in form, as in the actual recreation. We’ll first import the turtle module in or code and use its Display screen class to create the display screen object and customise it to have a width of 800px and a top of 600px utilizing the Display screen class setup() technique. We’ll set the background colour to black utilizing the bgcolor() technique, and title the display screen as “Pong Game” utilizing the title() technique. Under is the code, the place we’ve got created the display screen object:

from turtle import Turtle, Display screen

#Organising the Recreation Display screen
display screen = Display screen()
display screen.setup(width=800, top=600)
display screen.bgcolor("black")
display screen.title("Pong Game")


display screen.exitonclick()

Discover that we’ve got written the final line the place we’ve got used the display screen’s exitonclick() technique in order to make sure the display screen will stay there till we click on on it.

When you discover any confusion within the above strategies, be happy to take a look at the official documentation of the Turtle Module from right here.

Following is the output as we run this system:

Creating the Paddle & Paddle Class

The following job is to create a paddle, which is a rectangular-shaped object at either side of the Recreation Display screen. We’ll create this paddle utilizing the turtle module’s form() operate, and customise it to be white in colour utilizing the colour() technique, and use the shapesize() technique to customize it to have a width of 20px and a top of 100px. Discover that we’ve got handed 5 and 1 because the arguments to the shapesize() technique. It’s because the shapesize() is just not in pixels, however in reference to a base of 20px. So to get a size of 100px, we are going to go 5 (as 20px x 5 = 100px). Furthermore, we are going to place it such that initially of the sport it’s in the course of the proper aspect, that’s, a y coordinate of 0 and an x coordinate of 350 (bear in mind our display screen is 800px large). We’ll use the penup() technique to take away the turtle’s hint and make it transfer to the specified location utilizing the goto() technique.

#Creating the Paddle
paddle = Turtle()
paddle.form("square")
paddle.colour("white")
paddle.shapesize(5,1)
paddle.penup()
paddle.goto(350,0)

The next is the output of the above code. We will see a paddle created on the Recreation Display screen on the proper aspect, with none turtle hint.

Operating the above code will create the paddle. Nevertheless, we are able to see that the paddle is first created, after which it goes to its location. With a purpose to flip off the animation, we are going to add the display screen’s class tracer() technique in our code. This can even require us to replace the display screen manually:

#Retain the Unique Code
display screen.tracer(0)

display screen.replace()
display screen.exitonclick()

Calling the tracer() technique and passing it a price of 0 will flip off the animation.

As soon as we’ve got created the paddle and up to date the display screen by turning off the animations, subsequent is to configure the paddle actions. To do that, we are going to use display screen listeners. The display screen’s class pay attention() technique permits us to take heed to keyboard occasions, and the onkey() technique permits us to name an outlined operate each time a selected secret’s pressed. We’ll thus outline the go_up and go_down capabilities that can make the paddle transfer up and down alongside the y-axis.

    def go_up():
        new_y = paddle.ycor() + 40
        paddle.goto(paddle.xcor(), new_y)

    def go_down():
        new_y = paddle.ycor() - 40
        paddle.goto(paddle.xcor(),new_y)

As will be seen, we’ve got outlined the paddle’s up and down motion operate by making it transfer 40px vertically from its authentic place. Subsequent, we are going to use the display screen listeners functionality to permit these capabilities to be referred to as on urgent keyboard keys.

display screen.pay attention()
display screen.onkey(paddle.go_up, "Up")
display screen.onkey(paddle.go_down, "Down")

Now that we’ve got created the paddle and configured the mechanism of its motion, allow us to now shift our code to Object Oriented Programming Method. It’s because we are going to want 2 paddles for the sport, and having a generic blueprint that creates paddles immediately will make our job simpler. We’ll refactor our code to create one other paddle simply. We’ll transfer all of the paddle associated code to a different file and create the padlle class in it.

For the reason that paddles we’re creating are in essence turtle objects, we are going to make this paddle class inherit from the Turtle class. So we are going to create a brand new python file in our PyCharm IDE and once more import the turtle module’s Turtle class on this separate Python file. Subsequent, we are going to use the category creation syntax and def __inti__() to outline the Paddle class. As each the left and proper paddles can have completely different positions throughout the sport display screen, we are going to add the x and y coordinates as attributes to the category.

Now we are going to use the idea of inheritance in OOP and make the Turtle class the tremendous class, and the paddle class will inherit its attributes and strategies. Subsequent, we are going to simply change the phrase “paddle” in our former code the place we created the paddle with the “self” key phrase.

from turtle import Turtle, Display screen

class Paddle(Turtle):
    def __init__(self,x,y):
        # Creating the Paddle Objects
        tremendous().__init__()
        self.form("square")
        self.colour("white")
        self.shapesize(5, 1)
        self.penup()
        self.x = x
        self.y = y
        self.goto(x,y)

    # Configure Paddle Motion
    def go_up(self):
        new_y = self.ycor() + 40
        self.goto(self.xcor(), new_y)

    def go_down(self):
        new_y = self.ycor() - 40
        self.goto(self.xcor(),new_y)

As will be seen above, we’ve got additionally outlined the 2 strategies of Paddle class. One is the upward motion and the second is the downward motion that we’ve got already outlined earlier. As soon as the Paddle class is outlined, we are going to create the paddle objects and configure the up and down actions of each paddles:

from paddle import Paddle

# Creating Paddle Objects
left_paddle = Paddle(-350, 0)
right_paddle = Paddle(350, 0)

# Configuring Paddles' Motion
display screen.pay attention()
display screen.onkey(right_paddle.go_up, "Up")
display screen.onkey(right_paddle.go_down, "Down")
display screen.onkey(left_paddle.go_up, "w")
display screen.onkey(left_paddle.go_down, "s")

Operating the Recreation

With a purpose to run the sport and replace it utilizing the Display screen’s replace() technique, we are going to outline some time loop that can proceed to run till externally stopped, or when the situation of the loop turns to False.

#Recreation is ON:
game_is_on = True
whereas game_is_on:
    display screen.replace()

Now, while you run the principle file, you will notice the sport display screen and paddles created, and the power of the paddles to maneuver.

Create the Ball Class & Objects

Now persevering with on our OOP method to code this recreation, we are going to create the Ball class because the generic blueprint and create the ball object from it in our primary Python file. We’ll create the ball as a turtle object, by making the Ball class inherit from the tremendous class Turtle. We’ll use the turtle class’s strategies colour() and form() to initialize a ball of white colour in a round form. As earlier than, we are going to use the penup() technique of turtle to cover the turtle’s hint.

from turtle import Turtle

class Ball(Turtle):

    def __init__(self):
        tremendous().__init__()
        self.colour("white")
        self.form("circle")
        self.penup()

Now that our ball’s attributes are outlined, we can even create the ball’s strategies of shifting as quickly as the sport begins. The sport will begin with the ball being on the centre of the sport display screen, and when the display screen refreshes, it is going to be shifting in the proper route first. In our primary whereas loop we are going to name this technique so the ball will proceed to maneuver all through when the sport is on, that’s, its x and y coordinates will change at each refresh of the sport display screen.

The way in which to make the ball transfer is by altering each its x and y coordinates by a sure quantity, allow us to say 10 in the interim. We’ll outline the transfer() technique of the ball and code the above state of affairs:

class Ball(Turtle):

    #Retain earlier code
    def transfer(self):
        new_x = self.xcor() + 10
        new_y = self.ycor() + 10
        self.goto(new_x, new_y)

We’ll add this technique of the ball object to be referred to as inside the sport’s whereas loop:

#Recreation is ON:
game_is_on = True
whereas game_is_on:
    display screen.replace()
    ball.transfer()

On operating the code, we see that the ball vanishes shortly, and what we’re left with is simply the two paddles.

We will resume the animation by commenting out the display screen.tracer() traces and rerunning the code. We’ll now see the two paddles and the ball being created and moved.

One other strategy to visualise that is utilizing the time module and bringing a delay in the principle whereas loop of the sport. This may be carried out as follows (with out commenting out the tracer() operate):

import time

#Retain the Unique Code
#Recreation is ON:
game_is_on = True
whereas game_is_on:
    time.sleep(0.1)
    display screen.replace()
    ball.transfer()

Now you possibly can see that the ball strikes at a slower tempo and we are able to catch it with a paddle.

Detecting Collision of Ball with High/Backside Wall

Now that our ball is created and operating, we have to design a mechanism to make the ball bounce when it hits the highest and backside partitions, as for the left and proper partitions, the ball ought to be caught by the left and proper paddles. If the ball is just not caught, it could imply the opposite participant scores some extent.

So, contemplating that our ball is shifting from the centre of the display screen to the highest proper nook, and it reaches the nook, it must bounce now. In straightforward phrases, bouncing would merely be a change of route within the y-axis, because the ball would nonetheless be going ahead within the x-axis. We’ll now outline a brand new technique of the Ball class referred to as bounce() and name it in the principle recreation loop when the ball reaches the boundary:

from turtle import Turtle

class Ball(Turtle):

    def __init__(self):
        tremendous().__init__()
        self.colour("white")
        self.form("circle")
        self.penup()
        self.x_move = 10
        self.y_move = 10

    def transfer(self):
        new_x = self.xcor() + self.x_move
        new_y = self.ycor() + self.y_move
        self.goto(new_x, new_y)

    def bounce(self):
        self.y_move *= -1

Discover that within the above, we’ve got outlined 2 new attributes of the Ball class, the x_move and the y_move, and have made them equal to 10. Then, within the transfer() technique, we’ve got changed the determine of 10 with these attributes. As will be seen, this turns out to be useful for our bounce() technique. Now, each time the ball bounces, it’s going to transfer in the wrong way to its earlier y place. This merely signifies that if the ball goes up, and collides with the wall, the y_move would change from +10 to -10, and the ball will transfer downwards, because the detrimental quantity would imply the ball is shifting down. Consequently, a collision with the underside wall would change this y_move from -10 to +10, and the ball will then transfer upwards.

Now, allow us to add this situation in the principle whereas loop:

whereas game_is_on:
    #Retain Unique Code

    #Detect Collision with High and Backside Partitions
    if ball.ycor() > 275 or ball.ycor() < -275:
        ball.bounce_y()

Within the code above, we’ve got added the situation of the collision with the partitions to be detected, after which the bounce() technique to be referred to as. You should utilize any worth for the boundaries, however by repeated tries, the worth of 275 is nice sufficient!

Detecting Collision with Paddle

Now that we all know find out how to make the ball bounce from the highest and backside partitions, the subsequent step is to detect a collision with the paddle and make the ball bounce from the paddle. We’ll make use of a similiar technique as earlier than, besides that now we’re speaking concerning the x-axis.

The traditional strategy to detect a collision between the ball and the wall is to make use of the space technique. If the space between the 2 is lower than a certain quantity, we are able to conclude that the two have touched/collided. Nevertheless, know that the distance() operate works by calculating the space between the facilities of the 2 turtle objects. In our case, one is a 20x20px ball, and the opposite is a 20×200 rectangular paddle. The gap between them would range alongside the size of the paddle. If the ball hits the paddle on its edge, the space() technique would fail to conclude that each of them have made contact.

We will add one other situation which might test if the ball has gone previous a sure level on the x-axis, over to the proper (within the case of the proper paddle), and it’s inside a 50px distance from the paddle, then the ball should have made contact. We’ll add this situation to the principle whereas loop. As soon as the collision is detected, we can have the ball bounce, however this time within the x-direction. Allow us to redefine our bounce capabilities so we’ve got each bounce capabilities, one for the x-axis when colliding with pthe addle, and the opposite on the y-axis when colliding with the wall:

    def bounce_y(self):
        self.y_move *= -1

    def bounce_x(self):
        self.x_move *= -1

whereas game_is_on:
    ...

    # Detect Collision of the Ball with the Proper Paddle
    if ball.distance(right_paddle) < 50 and ball.xcor() > 320:
        ball.bounce_x()

    # Detect Collision of the Ball with the Left Paddle
    elif ball.distance(left_paddle) < 50 and ball.xcor() < -320:
        ball.bounce_x()

Observe, we’ve got added a price of 320 after some hit and trial and visualizations of the ball colliding with the paddle.

If one of many paddles misses the ball, then the opposite participant will get some extent, and the sport restarts with the ball within the centre. With a purpose to test if the ball is missed by the paddle, we are able to visualize this by contemplating the ball going past a sure level on the horizontal axis. We all know that the width of the display screen is 800 and the paddle is at 350 alongside the x-axis, so the paddle really goes from 340 to 360 because it has a width of 20px, so if the ball goes past the 360 x axs, it means the paddles has missed the ball. This could imply we are going to reset the ball to the beginning place on the centre worth (0,0). We’ll outline a reset_position() technique of the ball that shall be referred to as when the above situation is met. Furthermore, we can even add a function that can reverse the ball’s route, so as an alternative of going to the proper, it’s going to go to the left.

Class Ball(Turtle):
    ...
    def reset_position(self):
        self.goto(0, 0)
        self.bounce_x()

The bounce_x() technique will trigger the ball to reverse route because it did when it could bounce off a paddle. Placing these circumstances within the recreation’s primary whereas loop:

whereas game_is_on:
    ...
    # Detect Proper Paddle Lacking the Ball
    if ball.xcor() > 380:
        ball.reset_position()

    # Detect Left Paddle Lacking the Ball
    if ball.xcor() < -380:
        ball.reset_position()

Operating the code above will present us what occurs when a paddle misses the ball; the ball would reverse its route and would go to the opposite padlle. Now all that’s left is to create a scoreboard to retailer and show the rating for every participant.

Creating the Scoreboard

With a purpose to show and replace the rating for every participant, we are going to outline a scoreboard class in a brand new python file. We’ll create the Scoreboard class inheriting from the turtle class, and can outline the attributes that can assist the turtle object to jot down. First we are going to initialize the 2 attributes, l_score and r_score and set them to 0 initially of the sport. We’ll outline two strategies, l_point and r_point which shall be referred to as each time a participant misses the ball, and can improve the factors of the opposite consumer. We can even outline a technique referred to as update_scoreboard(), and name it when a participant scores an extra level. This technique, when referred to as will merely replace the scoreboard.

Following is the Scoreboard Class creation:

from turtle import Turtle

class Scoreboard(Turtle):
    def __init__(self):
        tremendous().__init__()
        self.colour("white")
        self.penup()
        self.hideturtle()
        self.l_score = 0
        self.r_score = 0
        self.update_scoreboard()

    def update_scoreboard(self):
        self.clear()
        self.goto(-100, 200)
        self.write(self.l_score, align="center", font=("Arial", 40, "normal"))
        self.goto(100, 200)
        self.write(self.r_score, align="center", font=("Arial", 40, "normal"))

    def l_point(self):
        self.l_score += 1
        self.update_scoreboard()

    def r_point(self):
        self.r_score += 1
        self.update_scoreboard()

The update_scoreboard() technique creates a turtle that writes the rating of each gamers on the principle display screen. Discover that we’ve got used the Turtle module’s write() operate in right here.

Subsequent we are going to import and create a scoreboard object in the principle file, and we are going to use this object to entry its strategies, satisfying the 2 circumstances: each time a participant’s paddle misses the ball, the opposite participant would get some extent.

from scoreboard import Scoreboard

#Initializing Scoreboard Object
scoreboard = Scoreboard()

whereas game_is_on:
    ...
   # Detect Proper Paddle Lacking the Ball
    if ball.xcor() > 380:
        ball.reset_position()
        scoreboard.l_point()

    # Detect Left Paddle Lacking the Ball
    if ball.xcor() < -380:
        ball.reset_position()
        scoreboard.r_point()

That is the place the sport designing and coding involves its finish. Runing the principle python file will generate the sport display screen and its parts, with the ball shifting as the sport begins. Now you simply must fins a participant to play this recreation with!

You can too change the pace of the sport by some adjustments within the code (that’s so that you can work out!)

Conclusion

On this article, we’ve got developed the basic Pong recreation with the assistance of the Python Turtle module. We’ve used the idea of Object Oriented Programming to create lessons, initialize attributes and strategies, and from these lessons create objects in the principle recreation file. That is an intermediate-level Python mission, and for those who stumbled upon some a part of the code, be sure that to both check with the Python official documentation or revise your primary ideas, notably OOP on this case.