cellphone my mom had is intently associated to the sport it had. Sure, the classical snake recreation, so easy but so addicting. I bear in mind taking part in this recreation on finish on my mom’s telephone, shedding after which making an attempt many times!
On this article, we are going to be taught to construct a easy Snake Sport. We’ll use Python’s turtle module in an effort to generate this recreation. Notice that this can be a novices to intermediate stage Python tutorial, and expects the reader to be accustomed to Python fundamentals comparable to capabilities and loops, importing and accessing modules, and utilizing conditional statements. It additionally requires one to have a surface-level understanding of Object Oriented Programming, particularly creating objects cases from courses. For the sake of simplicity, I’ll clarify every line of code. Let’s get began!
Understanding the Sport
The classical Snake recreation entails a small snake with a plain background. Meals is supplied on the display screen. Because the snake eats the meals, it grows in measurement, and the rating will increase. As quickly because the snake collides with the boundary wall or itself, the sport ends, and one loses.
With a view to code this recreation in Python, we might want to deal with the next factors:
- Organising the Sport Display – within the classical Snake recreation, the background is a boring neon yellow-green display screen
- Creating the Snake physique – the sport begins with a small black snake, which regularly will increase in measurement because it eats the meals
- Transferring the Snake – the snake can transfer within the 4 instructions: up, down, left, and proper by way of the arrow keys on the keyboard or corresponding buttons on the telephone
- Creating the Meals – the meals for the snake seems at random places on the display screen
- The Snake consuming the Meals – because the snake’s physique collides with the meals created, the rating is elevated in addition to the size of the snake, and new meals is generated randomly, and the sport continues.
- The Snake Colliding with itself or the Boundary Wall – if the snake’s physique collides with itself or the boundary of the sport display screen, the sport ends.
Allow us to begin coding.
Organising the Sport Display
First issues first, we are going to create a brand new venture in our IDE, let’s name it “Snake Sport”. I’m utilizing PyCharm to code. Subsequent, we are going to create a brand new “snake recreation.py” file. To start with, we are going to import the Turtle module, particularly its Display and Turtle courses.
from turtle import Display, TurtleThe Turtle Module is a built-in Python bundle that permits one to attract shapes, traces, patterns, and animations on a display screen by way of code. The module works as if there’s a turtle with a brush on its again, and no matter you command it to go to, it should go there, thereby creating drawings. You may ask the turtle to maneuver ahead, to show left by a sure angle, draw a circle and so on. The turtle will draw precisely that, and it’s a straightforward device to visualise one’s code. It helps practising variables, loops, capabilities, coordinates, and fundamental animation logic with on the spot visible outputs.
You may try the Turtle Official Documentation right here.
As could be seen within the line of code above, we’ve got imported two components: Display and Turtle. These are courses which are outlined within the module. In Python, a category is a blueprint used to create objects. Turtle and Display are courses which will probably be used to create corresponding objects. These objects could have attributes (variables) and strategies (capabilities) as outlined of their blueprint, with the supply of customization.
Allow us to first create the background for our recreation. We’ll use the Display class for this goal and customise it based on our necessities. For reference, test the Display strategies from the official documentation right here.
#Organising the Sport Display
display screen = Display()
display screen.setup(width=600, peak=600)
display screen.bgcolor("inexperienced yellow")
display screen.title("Snake Sport")
display screen.tracer(0)
display screen.exitonclick()As could be seen within the code above, we first created the display screen object from the Display Class. Subsequent, we’ve got used the setup() methodology of the Display class and set the width of the Sport Display to 600×600. We now have personalized the background shade to “inexperienced yellow” utilizing the bgcolor() methodology. The title of the colour could be discovered by way of this hyperlink. I chosen the colour that intently resembled the colour within the unique recreation. After that, we’ve got named the display screen “Snake Sport” utilizing the title() methodology. The tracer() methodology from the Turtle class lets us management the animation. By giving an argument of “0”, we’ve got turned it off. This will probably be higher understood once we create the snake and meals. Lastly, we’ve got used the exitonclick() methodology to set the window to shut solely once we click on on it. In any other case, the window closes as quickly because it pops up and executes the entire code.
Operating the code above would output the next:
Creating the Snake Physique
As soon as we’ve got created the Sport Display, the following job is to create the snake. The snake will even be created utilizing the Turtle class. We’ll create 3 turtle objects that received’t resemble a turtle in any respect. Quite, they are going to be sq. segments, and when positioned collectively, will resemble a snake’s physique, similar to within the recreation. For this goal, we are going to use a for loop to create the three segments. Every section will probably be positioned at a specified place. Allow us to code this:
#Creating the Snake
segments = []
starting_positions = [(0,0), (-20,0), (-40,0)]
for place in starting_positions:
new_segment = Turtle("sq.")
new_segment.shade("black")
new_segment.penup()
new_segment.shapesize(1,1)
new_segment.goto(place)
segments.append(new_segment)
display screen.replace()Within the code above, we first created an empty listing of segments. This listing will include the snake segments. As soon as the snake segments are created, it should consist of three segments, and every time the snake eats its meals, the variety of segments will improve. We now have created a tuple starting_positions. This may include 3 positions specified when it comes to their x and y coordinates, and would be the positions the place the snake segments will probably be created. We’ll create the primary section at (0,0), the second at (-20,0), and the third section at (-40,0). Utilizing the for loop, we’ve got created 3 segments from the variable new_segment as a turtle object, of sq. form and customary measurement 20×20. The arguments to shapesize() methodology is given as 1×1 because it stretches the scale of the drawing cursor relative to its default 20×20 pixel measurement. The penup() methodology permits us to cover the pen, and simply output the form of the turtle object. The goto() methodology permits us to create the form ranging from that place. Lastly, we’ve got appended the newly created section to the empty listing we created to start with of this code block. On this manner, 2 extra segments will probably be created as there are 2 extra positions within the starting_positions tuple.
In the long run, we are going to replace our display screen in order that it now reveals each the personalized display screen and the newly created snake. This would be the output:
Discover that we’ve got created the segments utilizing simply the for loop. As we go forward in our program, we might want to improve the snake’s segments because it eats the meals. With a view to make this addition handy to us, allow us to modify the code block and add a perform referred to as add_segments, to create the snake in addition to use it later when including segments to the snake when it eats the meals. This will probably be a greater strategy to programming within the present situation:
#Creating the Snake
segments = []
starting_positions = [(0,0), (-20,0), (-40,0)]
#Including Segments Operate
def add_segments(place):
new_segment = Turtle("sq.")
new_segment.shade("black")
new_segment.penup()
new_segment.goto(place)
segments.append(new_segment)
for place in starting_positions:
add_segments(place)
display screen.replace()Within the above code block, we’ve got executed precisely what we had been beforehand doing, that’s, creating the snake physique, besides that we’ve got used a Python perform to take action. We now have outlined a perform referred to as add_segments, whose goal is simply so as to add the segments to the snake’s physique, and the segments listing. Furthermore, now’s the place the display screen’s tracer() methodology comes to make use of. When you remark out the display screen.tracer() line that we added within the begining you will note the animation of the snake’s physique being created one section at a time (and we don’t need that in our recreation!). This could higher be visualized by first importing the time module and utilizing the sleep() perform. The animation will probably be extra seen.
import time
#Hold the remainder of the code similar
for place in starting_positions:
add_segments(place)
time.sleep(1)
display screen.replace()Snake Motion
The subsequent job is to code the snake’s motion. To start with, allow us to simply make the snake transfer ahead. We’ll first create a variable game_is_on that will probably be True so long as the sport is operating, and will probably be switched to False as soon as we lose or the sport ends. This variable will probably be used within the whereas loop. So long as the sport is on, the snake will proceed shifting, and we are going to solely be capable of change its route utilizing the arrow keys. That is going to be the a part of our program that can hold the sport on.
Now comes the advanced half. To maneuver the snake ahead, we have to transfer all of its segments forward. The best way to make the complete snake physique transfer ahead is by making every section, apart from the primary one, to maneuver to the one earlier than it. Because of this initially, when the snake is barely 3 segments lengthy, section 3 will transfer to the place of section 2, and section 2 will transfer to the place of section 1, and section 1 will transfer ahead utilizing the turtle ahead() methodology. This may be coded within the for loop, by giving it a beginning worth of the final ingredient of the listing, which is the ingredient on the 2nd place (listing components begin from 0, thus 0, 1, 2) when the snake is created (having 3 segments) or in any other case calculated because the size of the segments, minus 1. The for loop will finish at place 0, and as it’s shifting in reverse, we are going to give it a step measurement of -1. This complete situation is coded as beneath:
game_is_on = True
whereas game_is_on:
display screen.replace()
time.sleep(0.1)
for seg_num in vary(len(segments)-1, 0, -1):
new_x = segments[seg_num - 1].xcor()
new_y = segments[seg_num - 1].ycor()
segments[seg_num].goto(new_x, new_y)
segments[0].ahead(20)Discover that we’ve got added the display screen’s replace() methodology, in addition to outlined the pace of the snake utilizing the time module’s sleep() perform. By giving it an argument of 0.1, the snake segments will transfer ahead with a time delay of 0.1 seconds, and this pace could be adjusted. If given an argument of 1, the time delay will probably be 1 second, and the pace of the snake will probably be sluggish. You may experiment with the snake’s pace by altering the values given to the sleep() perform.
The within of the for loop elaborates how the segments will transfer to the earlier segments’ place utilizing its coordinates. And on the finish, we’ve got the primary section of our snake shifting forward by 20 utilizing the turtle’s ahead() methodology. Operating our code would output a shifting snake:
Controlling the Snake
Now that we’ve got seen easy methods to make the snake transfer, the following factor is to manage the up/down/left/proper actions of the snake. For this, we are going to use the display screen listeners. We’ll code this system in order that on urgent the up, down, left, and proper keys, the snake will transfer accordingly by altering its head.
Yet one more function that we have to add, taking it from the unique snake recreation, is that when the snake is shifting left, it can not straight flip proper, when it’s shifting up, it can’t straight flip downwards. Briefly, the snake can not flip 180 levels from the place it’s shifting. Allow us to add this function to our code. Be sure so as to add these traces of code earlier than the sport’s whereas loop we coded earlier.
#Controlling the Snake
display screen.hear()
def turn_up():
if segments[0].heading() != 270:
segments[0].setheading(90)
def turn_down():
if segments[0].heading() != 90:
segments[0].setheading(270)
def turn_left():
if segments[0].heading() != 0:
segments[0].setheading(180)
def turn_right():
if segments[0].heading() != 180:
segments[0].setheading(0)
display screen.onkey(turn_up, "Up")
display screen.onkey(turn_down, "Down")
display screen.onkey(turn_left, "Left")
display screen.onkey(turn_right, "Proper")As could be seen above, we first used the display screen’s hear() methodology that lets us take heed to the display screen’s enter keys. Subsequent, we’ve got outlined capabilities which will probably be referred to as later within the display screen’s onkey() methodology, which calls a perform primarily based on a keyboard key pressed. We now have outlined 4 capabilities, every to show to a route apart from the exact opposite, utilizing the turtle’s methodology setheading(). This methodology units the top of the turtle, which is the primary section or section[0] to 0, 90, 180, or 270, that’s, proper, up, left, or down. The if conditional statements in every perform make it possible for the snake doesn’t flip in its other way, as we will see within the unique recreation.
Operating the entire code with this code block addition will allow us to transfer our snake:
Meals Creation
As soon as the snake has been created and programmed to maneuver utilizing the arrow keys, the following job is to create the meals which the snake will eat and develop. This meals will even be created as a turtle object in a round form, in pink. We’ll set the shapesize to 0.5 so the meals is 10×10 pixels on the display screen. We now have additionally set the pace() to “quickest” so the animation is quick, and there’s no delay in meals creation. Right here, we are going to import Python’s random module to create the meals at random positions on the sport display screen. We now have set the boundary of meals as -275 to 275 on each the x and y axes. That is in order that it’s simpler for the snake to eat its meals with out colliding with the outer display screen boundary.
Furthermore, every time the snake eats its meals, new meals must be generated. For this goal, we are going to outline a perform refresh() and generate new random coordinates the place the turtle object referred to as meals will transfer to. Take a look at the code beneath:
#Creating the Meals
import random
meals = Turtle()
meals.shade("pink")
meals.form("circle")
meals.penup()
meals.shapesize(stretch_len=0.5, stretch_wid=0.5)
meals.pace("quickest")
random_x = random.randint(-275, 275)
random_y = random.randint(-275, 275)
meals.goto(random_x, random_y)
def refresh():
random_x = random.randint(-275, 275)
random_y = random.randint(-275, 275)
meals.goto(random_x, random_y)
Detect Collision with Meals
As soon as we’ve got created the meals, we now should create a mechanism whereby the snake eats the meals. Because of this every time the snake touches the meals, the meals vanishes, and the snake grows by one section. We’ll code this situation such that every time the snake and meals are in shut proximity, in order that their distance is lower than 15, it means the snake has eaten the meals. We’ll make use of the turtle module’s distance() methodology that calculates the gap between a turtle and a selected level or one other turtle object. If this distance is lower than 15 (by way of trial and error), it could imply the snake has touched or eaten its meals, and the meals ought to now transfer to a brand new location for recreation continuity. Therefore, we are going to now name the refresh() perform that we outlined earlier to maneuver the meals object to a brand new location. Consuming the meals ought to improve the snake’s measurement by a section. For this, we are going to outline a perform referred to as lengthen() outdoors the whereas loop and name it contained in the if conditional assertion when the snake eats the meals.
#Snake extending
def lengthen():
add_segments(segments[-1].place())As could be seen, the lengthen() perform will add a brand new section to the final section of the snake’s physique. Now shifting on to the primary recreation’s loop:
game_is_on = True
whereas game_is_on:
...
#Retain the unique code right here
...
#Detect Collision with Meals
if segments[0].distance(meals) < 15:
refresh()
lengthen()
Scoreboard and Rating Updation
Subsequent is to create a scoreboard that will show the rating. To do that, we are going to code outdoors the whereas loop. We’ll create this scoreboard and the rating as 2 turtle objects utilizing turtle’s write() methodology, which permits us to show textual content on display screen. First, we are going to initialize a variable referred to as rating as 0. Because the snake eats its meals, the rating variable will probably be elevated by 1 every time. Subsequent, we are going to create 2 turtle cases, scoreboard and my_score. The scoreboard object will show the textual content on display screen “Rating = “, whereas the my_score object will show the rating variable, which can change because the snake eats its meals. As could be seen within the code beneath, each of those turtle objects have been personalized for the display screen textual content show based on the necessity.
#Creating the Scoreboard & Rating
rating = 0
scoreboard = Turtle()
scoreboard.shade("black")
scoreboard.penup()
scoreboard.hideturtle()
scoreboard.goto(0,250)
scoreboard.write("Rating = ", True, align="middle", font=("Arial", 12, "regular"))
my_score = Turtle()
my_score.shade("black")
my_score.penup()
my_score.hideturtle()
As soon as we’ve got created the above, we are going to now proceed so as to add the supply of fixing the core inside the whereas loop of the sport, contained in the if conditional assertion when the snake collides with the meals. Verify the code beneath and replace the particular traces of code:
game_is_on = True
whereas game_is_on:
...
#Retain the unique code right here
...
#Detect Collision with Meals
if segments[0].distance(meals) < 20:
refresh()
lengthen()
rating = rating + 1
my_score.goto(40, 250)
my_score.clear()
my_score.write(rating, True, align="middle", font=("Arial", 12, "regular"))The next is displayed on the display screen after operating this system with the above additions:
Sport Ending
When the sport ends, we have to inform the person that the sport is over, reasonably than simply closing the show display screen. For this we are going to outline a perform and name it every time the sport ends: both by collision with a wall or by collision with tail. We’ll use the turtle object for this as properly. That is the perform, and will probably be referred to as when game_is_on variable turns to False.
#Sport Over Pop Up
def game_over():
game_over = Turtle()
game_over.shade("black")
game_over.penup()
game_over.hideturtle()
game_over.write("GAME OVER", True, align="middle", font=("Arial", 40, "regular"))
Detect Collision with Wall
One other situation of the sport’s continuity is to verify the snake doesn’t collide with the boundary wall of the display screen. With a view to code this, and understanding that the sport’s display screen is 600×600, we are going to contemplate the boundary wall a sq. with its corners to be at these factors: (290, 290), (290, -290), (-290, -290) and (-290, 290). The wall detection block will probably be inside the recreation loop in a separate if conditional assertion as follows:
game_is_on = True
whereas game_is_on:
...
#Retain the unique code right here
...
# Detect Collision with Wall
if segments[0].xcor() > 290 or segments[0].xcor() < -290 or segments[0].ycor() > 290 or segments[0].ycor() < -290:
game_is_on = False
game_over()
Within the above traces of code, we’ve got accessed the x and y coordinates of the primary section of the snake and checked whether or not it falls inside or outdoors of the boundary wall.
Detect Collision with Tail
Lastly, we are going to finish this program with one other situation of the sport, which is that if the snake’s head collides with itself, that’s, the primary section collides with another section, the sport ends. We’ll use the for loop to code this situation:
game_is_on = True
whereas game_is_on:
...
#Retain the unique code right here
...
# Detect Tail Collision
for section in segments[1:]:
if segments[0].distance(section) < 10:
game_is_on = False
game_over()
When the sport ends, we have to inform the person that the sport is over, reasonably than simply closing the show display screen. For this, we are going to name the game_over perform we outlined earlier.
Conclusion
On this tutorial, we’ve got efficiently carried out the snake recreation in Python. We now have used our understanding of Python fundamentals, comparable to defining and calling capabilities, utilizing lists and tuples, utilizing for and whereas loops in addition to conditional statements. We now have additionally carried out our fundamental understanding of Object Oriented Programming to create objects from a module’s courses. If in case you have any queries concerning any piece of code or a suggestion to make the code extra sturdy and environment friendly, be happy to remark and share your concepts. Till then, code, play, and problem your pals to the Snake Sport you could have designed!
