First off is "procedural event driven programming" a thing? My question is about global variables in the context of an event driven program that doesn't use OOP...

I have written a simple Snake game in Python which makes modest use of global variables. I have been been warned about the evils of globals so often that I thought I'd try and refactor the program to pass arguments instead.

It seems to me that any semblance of elegance or simplicity was lost in this endeavor. The version with globals is shown at the bottom of this post. Here's an excerpt from my attempt at refactoring:

def go_up(screen, pen, snake, snake_direction, food):
    if snake_direction != "down":
        snake_direction = "up"
        move_snake(screen, pen, snake, snake_direction, food)

    # Event handlers
    screen.onkey(lambda: go_up(screen, pen, snake, snake_direction, food), "Up")
    screen.onkey(lambda: go_right(screen, pen, snake, snake_direction, food), "Right")
    screen.onkey(lambda: go_down(screen, pen, snake, snake_direction, food), "Down")
    screen.onkey(lambda: go_left(screen, pen, snake, snake_direction, food), "Left")

    # Let's go
    snake = []
    snake_direction = ""
    screen, pen, snake, snake_direction, food = reset(screen, pen, snake, snake_direction, food)

It got very messy very quickly and I was unable to recreate the same functionality.

I'm pretty sure that even with a simple game like this, using OOP would be preferable to a procedural approach which involves so much argument passing.

But assuming I don't want to use OOP - say I want to teach kids how to write fun games without getting in that deep - is there any merit to using the argument passing approach over what appears to me to be the far more simple approach of having a few global variables?

Is this code evil?

A simple snake game using Turtle Graphics.
Todo:  border collision?, score
import turtle
import random

WIDTH = 500
HEIGHT = 500
DELAY = 100  # milliseconds

offsets = {
    "up": (0, 20),
    "down": (0, -20),
    "left": (-20, 0),
    "right": (20, 0)

def reset():
    global snake, snake_direction
    snake = [[0, 0], [0, 20], [0, 40], [0, 50], [0, 60]]
    snake_direction = "up"
    food_pos = get_random_food_pos()
    # screen.update() Only needed if we are fussed about drawing food before call to `draw_snake()`.

def move_snake():

    #  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]:  # Or collision with walls?
        # No self-collision so we can continue moving the snake.

        # Check food collision
        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

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

        # Refresh screen

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

def food_collision():
    if get_distance(snake[-1], (food.xcor(), food.ycor())) < 20:
        food_pos = get_random_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"

def main():
    global screen, pen, food

    # Screen
    screen = turtle.Screen()
    screen.setup(WIDTH, HEIGHT)
    screen.setup(500, 500)

    # Pen
    pen = turtle.Turtle("square")

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

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

    # Let's go

if __name__ == "__main__":
  • 2
    \$\begingroup\$ If you have working code that meets your needs, and you're looking for feedback on coding style or reducing "evil," you might want to consider taking this to the Code Review StackExchange instead, where they specialize in that. \$\endgroup\$
    – DMGregory
    Mar 20, 2020 at 8:39
  • \$\begingroup\$ Related reading alternatives to globals & using dependency injection in place of singletons. \$\endgroup\$
    – Pikalek
    Mar 20, 2020 at 14:45
  • \$\begingroup\$ As a side note - globals themselves aren't necessarily evil, thought they're easy to misuse & the odds of running into trouble tends to increase with size of the project. For something very small in scope, a few well used, easily identified globals maybe preferable to adding a heavier weight management system. \$\endgroup\$
    – Pikalek
    Mar 20, 2020 at 14:48


You must log in to answer this question.

Browse other questions tagged .