Snake videogame in Python

Question

I made a Snake game in Python 3 with pygame. Please do critique it as much as possible.

IMPORTANT NOTE: I updated the code at 3:30 3/23

# main.py
# [My Name]
import pygame
from pygame.locals import *
from vector import *
import better_exceptions
import random
import colr
import sys

SCREENSIZE = (1664, 960)
CELLSIZE = 64

assert not SCREENSIZE[0] % CELLSIZE, 'CELLSIZE must be a multiple of SCREENSIZE[0]'
assert not SCREENSIZE[1] % CELLSIZE, 'CELLSIZE must be a multiple of SCREENSIZE[1]'

TITLE = 'Snake'
FPS = 60

LINECOLOR = colr.white()
LINEWIDTH = 2

BGCOLOR = colr.gray()

SNAKECOLOR = colr.green()
SNAKEHEADCOLOR = colr.blue()
SNAKETICKRATE = 200  # Move the snake once every _ milliseconds
SNAKEGROWRATE = 1  # Amount of places to grow for each food eaten

SCREEN = pygame.display.set_mode(SCREENSIZE)

UP = (0, -1)
RIGHT = (1, 0)
LEFT = (-1, 0)
DOWN = (0, 1)


class Snake(object):
    def __init__(self, headPos, initSize):
        self.spots = [headPos]
        self.direction = UP
        self.currentDirection = self.direction
        self.timer = 0
        self.tickrate = SNAKETICKRATE
        self.headColor = SNAKEHEADCOLOR
        self.bodyColor = SNAKECOLOR
        self.growRate = SNAKEGROWRATE
        self.queue = 1
        self.grow(initSize)

    @property
    def head(self):
        return self.spots[-1]

    @staticmethod
    def getWorldCoords(spot):
        spotWorld = [spot[i] for i in range(2)]
        return spotWorld

    def lose(self):
        leave()

    def isOutsideMap(self, spot=None):
        spot = self.getWorldCoords(spot)
        # Check only one spot
        for i in (0, 1):
            if not 0 <= spot[i] < SCREENSIZE[i]:
                return True
        return False

    def isCollidingWithSelf(self, spot):
        # Check only one spot
        if spot in self.spots:
            return True
        return False

    def redir(self, direction):
        if not tuple((-direction[i] for i in range(2))
                     ) == tuple(self.currentDirection):
            self.direction = direction

    def move(self, keepOld=False):
        newSpot = [self.head[i] + self.direction[i] for i in range(2)]
        self.currentDirection = self.direction
        if self.isOutsideMap(newSpot) or self.isCollidingWithSelf(newSpot):
            self.lose()
        else:
            self.spots.append(newSpot)
            if not keepOld:
                del self.spots[0]

    def smartMove(self):
        if 0 < self.queue:
            self.move(True)
            self.queue -= 1
        else:
            self.move()
        if tuple(self.head) == tuple(foodSpawner.food):
            self.grow(self.growRate)
            foodSpawner.eat()

    def grow(self, amnt=1):
        self.queue += amnt

    def draw(self, deltaTime):
        self.timer += deltaTime
        if self.tickrate < self.timer:
            self.smartMove()
            self.timer = 0
        for spot in self.spots:
            color = self.bodyColor
            if tuple(spot) == tuple(self.head):
                color = self.headColor
            drawCellAtLocation(spot, color)


class FoodSpawner(object):
    def __init__(self, noFoodCheck=lambda: []):
        self.noFoodCheck = noFoodCheck
        self.food = self.genPos()
        self.color = colr.orange()

    def genPos(self):
        return random.choice(list(filter(lambda x: x not in map(tuple, self.noFoodCheck()), allCells())))

    def eat(self):
        self.food = self.genPos()

    def draw(self):
        drawCellAtLocation(self.food, self.color)


def allCells():
    return [(x, y) for y in range(SCREENSIZE[1] // CELLSIZE)
            for x in range(SCREENSIZE[0] // CELLSIZE)]


def drawCellAtLocation(spot, color=None):
    color = color or colr.white()
    spotRect = pygame.Rect([spot[i] * CELLSIZE + LINEWIDTH for i in range(2)],
                           [CELLSIZE - LINEWIDTH for _ in range(2)])
    pygame.draw.rect(SCREEN, color, spotRect)


def leave():
    sys.exit()


def draw(deltaTime):
    SCREEN.fill(BGCOLOR)
    drawGrid()
    snake.draw(deltaTime)
    foodSpawner.draw()


keybindings = {
    K_UP: lambda: snake.redir(UP),
    K_RIGHT: lambda: snake.redir(RIGHT),
    K_LEFT: lambda: snake.redir(LEFT),
    K_DOWN: lambda: snake.redir(DOWN),
}


def event(ev):
    if ev.type == KEYDOWN:
        try:
            keybindings[ev.key]()
        except KeyError:
            pass


def drawGrid():
    for x in range(0, SCREENSIZE[0], CELLSIZE):
        pygame.draw.line(SCREEN, LINECOLOR, (x, 0),
                         (x, SCREENSIZE[1]), LINEWIDTH)
    for y in range(0, SCREENSIZE[1], CELLSIZE):
        pygame.draw.line(SCREEN, LINECOLOR, (0, y),
                         (SCREENSIZE[0], y), LINEWIDTH)


fonts = {}


def getFont(self, size):
    if size not in fonts:
        fonts[size] = pygame.font.Font(None, size)
    return fonts[size]


texts = {}


def getText(self, text, size=12, color=None):
    color = color or colr.black()
    if (text, size, color) not in texts:
        fonts[(text, size, color)] = getFont(size).render(text, True, color)
    return fonts[(text, size, color)]


def roundedRect(surface, rect, color, radius=0.4):
    """ Draw a rounded rectangle """
    rect = pygame.Rect(rect)
    color = pygame.Color(*color)
    alpha = color.a
    color.a = 0
    pos = rect.topleft
    rect.topleft = 0, 0
    rectangle = pygame.Surface(rect.size, SRCALPHA)

    circle = pygame.Surface([min(rect.size) * 3] * 2, SRCALPHA)
    pygame.draw.ellipse(circle, (0, 0, 0), circle.get_rect(), 0)
    circle = pygame.transform.smoothscale(
        circle, [int(min(rect.size) * radius)] * 2)

    radius = rectangle.blit(circle, (0, 0))
    radius.bottomright = rect.bottomright
    rectangle.blit(circle, radius)
    radius.topright = rect.topright
    rectangle.blit(circle, radius)
    radius.bottomleft = rect.bottomleft
    rectangle.blit(circle, radius)

    rectangle.fill((0, 0, 0), rect.inflate(-radius.w, 0))
    rectangle.fill((0, 0, 0), rect.inflate(0, -radius.h))

    rectangle.fill(color, special_flags=BLEND_RGBA_MAX)
    rectangle.fill((255, 255, 255, alpha), special_flags=BLEND_RGBA_MIN)

    return surface.blit(rectangle, pos)


snake = Snake((5, 5), 500)
foodSpawner = FoodSpawner(lambda: snake.spots)

clock = pygame.time.Clock()
while True:
    deltaTime = clock.tick(FPS)

    draw(deltaTime)

    for ev in pygame.event.get():
        if ev.type == QUIT:
            leave()
        else:
            event(ev)

    pygame.display.update()
    pygame.display.flip()

Answer 1

Nice game. Here are some nits and tips:

1. For readability and clarity, put each of your classes in a separate file and import them from a runner script or game script.

2. Why the need to do this?

   def getWorldCoords(spot):
       spotWorld = [spot[i] for i in range(2)]
       return spotWorld
   

   You can write it like so:

   def getWorldCoords(spot):
       return spot[:2]
   

   Be aware that if you are modifying the objects in the list, you should use the copy to make a deep copy of them if they are not primitives.

3. Try to make your code less verbose.

   def isCollidingWithSelf(self, spot):
       return spot in self.spots
   

4. Unneeded list comprehensions.

   if not tuple((-direction[i] for i in range(2))
                ) == tuple(self.currentDirection):
       self.direction = direction
   

   This is extremely verbose and difficult to read.

   if (-direction[0], -direction[1]) != tuple(self.currentDirection):
       self.direction = direction
   

5. Avoid using sys.exit(). Try to have your program exit normally. You can just set a condition in your while loop.

6. Comments should not state the obvious. Use comments to document things like complex algorithms.

   def roundedRect(surface, rect, color, radius=0.4):
       """ Draw a rounded rectangle """
   

   This comment doesn't really add much value.

7. Enclose your main code using an if __name__ == '__main__': guard. Avoid putting it in the global scope.

Happy coding!