How To Create Snackgame in Turtle & Random Using Python

by Letscode - October 4,2023

Introduction:

Dive into the world of Python game development with a bite-sized, snacky adventure! Today, we'll create a simple and fun Snackgame using Python's Turtle graphics and the Random module. Let's get coding!

Prerequisites:

All you need is Python installed on your system. No prior game development experience required!

Technologies Used:

- Python: The magic wand for game development.

- Turtle: Your artistic companion for creating visuals.

- Random: The spice for unpredictability in our Snackgame.

Step 1: Game On - Setting Up:

Fire up your Python environment and initiate the game space. Think of it as the canvas for our snakey escapade.

Step 2: Sssslithering Snake - Drawing It:

Use Turtle commands to bring our snake to life on the screen. Make it responsive to keyboard controls for a seamless gaming experience.

Step 3: Surprise Snacks - Randomly Appearing:

Invoke the Random module to sprinkle snacks randomly across the screen. No monotony here – every game is a tasty surprise!

Step 4: Snack Attack - Game Logic:

As our snake gobbles up snacks, let's make sure the score jumps up, the snake grows, and new snacks pop in randomly. It's a snack attack party!

Step 5: Obstacles, Because Why Not:

For an extra twist, throw in some obstacles using Turtle graphics. The snake should navigate skillfully, avoiding collisions for a high score.

Step 6: Game Over - When It Ends:

Implement a graceful exit. When the snake hits a wall or an obstacle, end the game and display the final score. Game over, but what a ride!

Step 7: Scoreboard & UI Magic:

Let's not forget the glory – add a scoreboard to keep track of the snacking prowess. A sleek UI will make the gaming experience sweeter.

Step 8: Snazzy Customization:

Want a neon snake or disco snacks? Now's the time to customize! Experiment with colors, shapes, and sounds to make the Snackgame uniquely yours.

Step 9: Share the Snack Magic:

Feeling proud of your creation? Share it with friends! Consider uploading your Snackgame masterpiece on platforms like GitHub for the world to savor.

Conclusion:

In just a few bites of code, you've cooked up a delightful Snackgame. Python, Turtle, and a dash of randomness – a recipe for a snaky good time! Happy coding! 🐍🎮

Steps To Make Snackgame in Turtle & Random Using Python

• Create a folder. You can name this folder whatever you want, and inside this folder, create the mentioned files.
• Create an .py file. its extension .py

                        
#  Letscodeweb - Youtube
import turtle
import random

WIDTH = 500
HEIGHT = 500
FOOD_SIZE = 10
DELAY = 100
offsets = {
    "up": (0, 20),
    "down": (0, -20),
    "left": (-20, 0),
    "right": (20, 0)
}
def reset():
    global snake, snake_direction, food_pos, pen
    snake = [[0, 0], [0, 20], [0, 40], [0, 50], [0, 60]]
    snake_direction = "up"
    food_pos = get_random_food_pos()
    food.goto(food_pos)
    # screen.update() Only needed if we are fussed about drawing food before next call to `draw_snake()`.
    move_snake()


def move_snake():
    global snake_direction

    #  Next position for head of snake.
    new_head = snake[-1].copy()
    new_head[0] = snake[-1][0] + offsets[snake_direction][0]
    new_head[1] = snake[-1][1] + offsets[snake_direction][1]

    # Check self-collision
    if new_head in snake[:-1]:
        reset()
    else:

        snake.append(new_head)
        if not food_collision():
            snake.pop(0)  # Keep the snake the same length unless fed.

        #  Allow screen wrapping
        if snake[-1][0] > WIDTH / 2:
            snake[-1][0] -= WIDTH
        elif snake[-1][0] < - WIDTH / 2:
            snake[-1][0] += WIDTH
        elif snake[-1][1] > HEIGHT / 2:
            snake[-1][1] -= HEIGHT
        elif snake[-1][1] < -HEIGHT / 2:
            snake[-1][1] += HEIGHT

        # Clear previous snake stamps
        pen.clearstamps()

        # Draw snake
        for segment in snake:
            pen.goto(segment[0], segment[1])
            pen.stamp()

        # Refresh screen
        screen.update()

        # Rinse and repeat
        turtle.ontimer(move_snake, DELAY)


def food_collision():
    global food_pos
    if get_distance(snake[-1], food_pos) < 20:
        food_pos = get_random_food_pos()
        food.goto(food_pos)
        return True
    return False


def get_random_food_pos():
    x = random.randint(- WIDTH / 2 + FOOD_SIZE, WIDTH / 2 - FOOD_SIZE)
    y = random.randint(- HEIGHT / 2 + FOOD_SIZE, HEIGHT / 2 - FOOD_SIZE)
    return (x, y)


def get_distance(pos1, pos2):
    x1, y1 = pos1
    x2, y2 = pos2
    distance = ((y2 - y1) ** 2 + (x2 - x1) ** 2) ** 0.5
    return distance


def go_up():
    global snake_direction
    if snake_direction != "down":
        snake_direction = "up"


def go_right():
    global snake_direction
    if snake_direction != "left":
        snake_direction = "right"


def go_down():
    global snake_direction
    if snake_direction != "up":
        snake_direction = "down"


def go_left():
    global snake_direction
    if snake_direction != "right":
        snake_direction = "left"


# Screen
screen = turtle.Screen()
screen.setup(WIDTH, HEIGHT)
screen.title("Snake  Game")
screen.bgcolor("black")
screen.setup(1000, 1000)
screen.tracer(0)

# Pen
pen = turtle.Turtle("square")
pen.penup()
pen.pencolor("yellow")

# Food
food = turtle.Turtle()
food.shape("circle")
food.color("red")
food.shapesize(FOOD_SIZE / 20)  # Default size of turtle "square" shape is 20.
food.penup()

# Event handlers
screen.listen()
screen.onkey(go_up, "Up")
screen.onkey(go_right, "Right")
screen.onkey(go_down, "Down")
screen.onkey(go_left, "Left")

# Let's go
reset()
turtle.done()