I have written a Snake game using Python's Tkinter library.
I am a beginner to programming. I learned some python alone and in school. However, most of what we did in school is algorithms/data structures and problem-solving (school program geared towards mathematics). Not much coding.
Lately, I picked up Python again. I was introduced to OOP in Python and used Tkinter before deciding to give Snake a try. Anyway, here is a link to my code in github. This is my first quasi-real application.
Any comments, recommendations, bad/good habits are welcome.
from tkinter import*
from random import randint
# constants that go in the making of the grid used for the snake's movment
GRADUATION = 40
PIXEL = 10
STEP = 2 * PIXEL
WD = PIXEL * GRADUATION
HT = PIXEL * GRADUATION
# constants that go into specifying the shapes' sizes
OB_SIZE_FACTOR = 1
SN_SIZE_FACTOR = 0.9
OB_SIZE = PIXEL * OB_SIZE_FACTOR
SN_SIZE = PIXEL * SN_SIZE_FACTOR
# color constants
BG_COLOR = 'black'
OB_COLOR = 'red'
SN_COLOR = 'white'
# a dictionary to ease access to a shape's type in the Shape class
SN = 'snake'
OB = 'obstacle'
SIZE = {SN: SN_SIZE, OB: OB_SIZE}
# constants for keyboard input
UP = 'Up'
DOWN = 'Down'
RIGHT = 'Right'
LEFT = 'Left'
# a dictionary to ease access to 'directions'
DIRECTIONS = {UP: [0, -1], DOWN: [0, 1], RIGHT: [1, 0], LEFT: [-1, 0]}
AXES = {UP: 'Vertical', DOWN: 'Vertical', RIGHT: 'Horizontal', LEFT: 'Horizontal'}
# refresh time for the perpetual motion
REFRESH_TIME = 100
class Master(Canvas):
"""create the game canvas, the snake, the obstacle, keep track of the score"""
def __init__(self, boss=None):
super().__init__(boss)
self.configure(width=WD, height=HT, bg=BG_COLOR)
self.running = 0
self.snake = None
self.obstacle = None
self.direction = None
self.current = None
self.score = Scores(boss)
def start(self):
"""start snake game"""
if self.running == 0:
self.snake = Snake(self)
self.obstacle = Obstacle(self)
self.direction = RIGHT
self.current = Movement(self, RIGHT)
self.current.begin()
self.running = 1
def clean(self):
"""restarting the game"""
if self.running == 1:
self.score.reset()
self.current.stop()
self.running = 0
self.obstacle.delete()
for block in self.snake.blocks:
block.delete()
def redirect(self, event):
"""taking keyboard inputs and moving the snake accordingly"""
if 1 == self.running and \
event.keysym in AXES.keys() and\
AXES[event.keysym] != AXES[self.direction]:
self.current.flag = 0
self.direction = event.keysym
self.current = Movement(self, event.keysym) # a new instance at each turn to avoid confusion/tricking
self.current.begin() # program gets tricked if the user presses two arrow keys really quickly
class Scores:
"""Objects that keep track of the score and high score"""
def __init__(self, boss=None):
self.counter = StringVar(boss, '0')
self.maximum = StringVar(boss, '0')
def increment(self):
score = int(self.counter.get()) + 1
maximum = max(score, int(self.maximum.get()))
self.counter.set(str(score))
self.maximum.set(str(maximum))
def reset(self):
self.counter.set('0')
class Shape:
"""This is a template to make obstacles and snake body parts"""
def __init__(self, can, a, b, kind):
self.can = can
self.x, self.y = a, b
self.kind = kind
if kind == SN:
self.ref = Canvas.create_rectangle(self.can,
a - SN_SIZE, b - SN_SIZE,
a + SN_SIZE, b + SN_SIZE,
fill=SN_COLOR,
width=2)
elif kind == OB:
self.ref = Canvas.create_oval(self.can,
a - OB_SIZE, b - OB_SIZE,
a + SN_SIZE, b + SN_SIZE,
fill=OB_COLOR,
width=2)
def modify(self, a, b):
self.x, self.y = a, b
self.can.coords(self.ref,
a - SIZE[self.kind], b - SIZE[self.kind],
a + SIZE[self.kind], b + SIZE[self.kind])
def delete(self):
self.can.delete(self.ref)
class Obstacle(Shape):
"""snake food"""
def __init__(self, can):
"""only create the obstacles where there is no snake body part"""
self.can = can
p = int(GRADUATION/2 - 1)
n, m = randint(0, p), randint(0, p)
a, b = PIXEL * (2 * n + 1), PIXEL * (2 * m + 1)
while [a, b] in [[block.x, block.y] for block in self.can.snake.blocks]:
n, m = randint(0, p), randint(0, p)
a, b = PIXEL * (2 * n + 1), PIXEL * (2 * m + 1)
super().__init__(can, a, b, OB)
class Block(Shape):
"""snake body part"""
def __init__(self, can, a, y):
super().__init__(can, a, y, SN)
class Snake:
"""a snake keeps track of its body parts"""
def __init__(self, can):
"""initial position chosen by me"""
self.can = can
a = PIXEL + 2 * int(GRADUATION/4) * PIXEL
self.blocks = [Block(can, a, a), Block(can, a, a + STEP)]
def move(self, path):
"""an elementary step consisting of putting the tail of the snake in the first position"""
a = (self.blocks[-1].x + STEP * path[0]) % WD
b = (self.blocks[-1].y + STEP * path[1]) % HT
if a == self.can.obstacle.x and b == self.can.obstacle.y: # check if we find food
self.can.score.increment()
self.can.obstacle.delete()
self.blocks.append(Block(self.can, a, b))
self.can.obstacle = Obstacle(self.can)
elif [a, b] in [[block.x, block.y] for block in self.blocks]: # check if we hit a body part
self.can.clean()
else:
self.blocks[0].modify(a, b)
self.blocks = self.blocks[1:] + [self.blocks[0]]
class Movement:
"""object that enters the snake into a perpetual state of motion in a predefined direction"""
def __init__(self, can, direction):
self.flag = 1
self.can = can
self.direction = direction
def begin(self):
"""start the perpetual motion"""
if self.flag > 0:
self.can.snake.move(DIRECTIONS[self.direction])
self.can.after(REFRESH_TIME, self.begin)
def stop(self):
"""stop the perpetual movement"""
self.flag = 0
if __name__ == "__main__":
root = Tk()
root.title("Snake Game")
game = Master(root)
game.grid(column=1, row=0, rowspan=3)
root.bind("<Key>", game.redirect)
buttons = Frame(root, width=35)
Button(buttons, text='Start', command=game.start).grid()
Button(buttons, text='Stop', command=game.clean).grid()
Button(buttons, text='Quit', command=root.destroy).grid()
buttons.grid(column=0, row=0)
scoreboard = Frame(root, width=35, height=2 * HT / 5)
Label(scoreboard, text='Game Score').grid()
Label(scoreboard, textvariable=game.score.counter).grid()
Label(scoreboard, text='High Score').grid()
Label(scoreboard, textvariable=game.score.maximum).grid()
scoreboard.grid(column=0, row=2)
root.mainloop()
