class ExperimentalScene(Scene):
def __init__(self, screen, id=0):
super().__init__(screen, id)
def load(self):
self.boundary = Boundary(self.screen, 0, 0)
snake_position_x, snake_position_y = self.random_position()
self.snake = Snake(self.screen, snake_position_x, snake_position_y)
apple_position_x, apple_position_y = self.random_position()
self.apple = Apple(self.screen, apple_position_x, apple_position_y)
self.collision = Collision(self.boundary.get_boundaries())
def random_position(self):
x = random.randint(21, 379)
y = random.randint(21, 379)
return x, y
def draw(self):
self.boundary.draw()
self.apple.draw()
self.snake.draw_snake()
def limit_movements(self):
is_collider, object_collider = self.collision.check_collision(
self.snake)
if object_collider == self.boundary.horizontal_bar_left.get_rectangule(
):
self.snake.update(25, 0, 25, -25)
elif object_collider == self.boundary.horizontal_bar_right.get_rectangule(
):
self.snake.update(0, -25, 25, -25)
elif object_collider == self.boundary.vertical_bar_botton.get_rectangule(
):
self.snake.update(25, -25, 0, -25)
elif object_collider == self.boundary.vertical_bar_top.get_rectangule(
):
self.snake.update(25, -25, 25, 0)
else:
self.snake.update(25, -25, 25, -25)
def eat_apple(self):
is_collider, object_collider = self.collision.check_collision(
self.snake)
if self.collision.object_colision(self.snake, self.apple):
del self.apple
new_x, new_y = self.random_position()
self.apple = Apple(self.screen, new_x, new_y)
self.snake.grow_body(self.snake.get_position()[0],
self.snake.get_position()[1])
def update(self):
self.limit_movements()
self.eat_apple()
def game_loop(self):
"""The game loop for 1 player mode"""
snake_length = 6
snake = Snake(snake_length, color=GREEN, game=self)
apple = Apple(APPLE_SIZE, game=self)
def game_reset():
nonlocal snake, apple
snake = Snake(snake_length, color=GREEN, game=self)
apple = Apple(APPLE_SIZE, game=self)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.game_exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT and snake.direction != 'RIGHT' and not snake.turned:
snake.started = True
snake.turned = True
snake.turn('LEFT')
elif event.key == pygame.K_RIGHT and snake.direction != 'LEFT' and not snake.turned:
snake.started = True
snake.turned = True
snake.turn('RIGHT')
elif event.key == pygame.K_UP and snake.direction != 'DOWN' and not snake.turned:
snake.started = True
snake.turned = True
snake.turn('UP')
elif event.key == pygame.K_DOWN and snake.direction != 'UP' and not snake.turned:
snake.started = True
snake.turned = True
snake.turn('DOWN')
if snake.hit_wall() or snake.hit_tail():
self.show_score(snake, game_reset)
self.display.fill(WHITE)
pygame.draw.rect(self.display, BLACK, [0, self.height, self.width, PANEL_HEIGHT])
self.message("Score: " + str(snake.score), RED, h_align='left', v_align='bottom', off_set_y=20)
apple.draw()
snake.draw()
if snake.started:
snake.go()
snake.turned = False
pygame.display.update()
if snake.eat(apple):
apple = Apple(APPLE_SIZE, game=self)
CLOCK.tick(FPS)
def loop(self, screen):
screen.blit(self.text, self.textRect)
screen.blit(self.text2, self.textRect2)
clock = pygame.time.Clock()
self.snake = Snake(self.display, -(Config['snake']['width']))
self.snake2 = Snake(self.display, (Config['snake']['width']))
apple = Apple(self.display)
ai = Ai()
x_change = Config['snake']['speed']
y_change = 0
x_change2 = -Config['snake']['speed']
y_change2 = 0
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT and x_change == 0:
x_change = -Config['snake']['speed']
y_change = 0
elif event.key == pygame.K_RIGHT and x_change == 0:
x_change = Config['snake']['speed']
y_change = 0
elif event.key == pygame.K_UP and y_change == 0:
x_change = 0
y_change = -Config['snake']['speed']
elif event.key == pygame.K_DOWN and y_change == 0:
x_change = 0
y_change = Config['snake']['speed']
if event.key == pygame.K_a and x_change2 == 0:
x_change2 = -Config['snake']['speed']
y_change2 = 0
elif event.key == pygame.K_d and x_change2 == 0:
x_change2 = Config['snake']['speed']
y_change2 = 0
elif event.key == pygame.K_w and y_change2 == 0:
x_change2 = 0
y_change2 = -Config['snake']['speed']
elif event.key == pygame.K_s and y_change2 == 0:
x_change2 = 0
y_change2 = Config['snake']['speed']
snake_rect = self.snake.draw(Config['colors']['blue'])
snake_rect2 = self.snake2.draw(Config['colors']['green'])
apple_rect = apple.draw()
ai.update(pos=(snake_rect[0], snake_rect[1]),
apple=(apple_rect[0], apple_rect[1]),
size=self.snake.max_size)
move = ai.action()
bumper_x = Config['game']['width'] - Config['game']['bumper_size']
bumper_y = Config['game']['height'] - Config['game']['bumper_size']
if apple_rect.colliderect(snake_rect):
apple.remove()
apple.randomize()
self.snake.eat()
elif apple_rect.colliderect(snake_rect2):
apple.remove()
apple.randomize()
self.snake2.eat()
snakehit = self.snake.hit(self.snake2.body, bumper_x, bumper_y)
snakehit2 = self.snake2.hit(self.snake.body, bumper_x, bumper_y)
if (snakehit or snakehit2):
if (snakehit and snakehit2):
print("Tie")
elif snakehit:
self.snake2.score += 1
self.player2score += 1
else:
self.snake.score += 1
self.player1score += 1
apple.remove()
# snake.remove()
self.map(screen)
self.loop(screen)
self.snake.move(x_change, y_change)
self.snake2.move(x_change2, y_change2)
pygame.display.update()
clock.tick(Config['game']['fps'])
def loop(self):
clock = pygame.time.Clock()
snake = Snake(self.display)
apple = Apple(self.display)
x_change = 0
y_change = 0
self.score = 0
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
x_change = -Config['snake']['speed']
y_change = 0
elif event.key == pygame.K_RIGHT:
x_change = Config['snake']['speed']
y_change = 0
elif event.key == pygame.K_UP:
x_change = 0
y_change = -Config['snake']['speed']
elif event.key == pygame.K_DOWN:
x_change = 0
y_change = Config['snake']['speed']
#Background and game area
self.display.fill(Config['colors']['red'])
pygame.draw.rect(self.display, Config['colors']['black'], [
Config['game']['bumper_size'], Config['game']['bumper_size'],
Config['game']['height'] - Config['game']['bumper_size'] * 2,
Config['game']['width'] - Config['game']['bumper_size'] * 2
])
#apple
apple_rect = apple.draw()
#move the snake
snake.move(x_change, y_change)
#Draw the snake
snake_rect = snake.draw()
snake.draw_body()
#collision
bumper_x = Config['game']['width'] - Config['game']['bumper_size']
bumper_y = Config['game']['height'] - Config['game']['bumper_size']
if (snake.x_pos < Config['game']['bumper_size']
or snake.y_pos < Config['game']['bumper_size']
or snake.x_pos + Config['snake']['width'] > bumper_x
or snake.y_pos + Config['snake']['height'] > bumper_y):
self.loop()
# Detect collision with apple
if apple_rect.colliderect(snake_rect):
apple.randomize()
self.score += 1
snake.eat()
# Collide with Self
if len(snake.body) >= 1:
for cell in snake.body:
if snake.x_pos == cell[0] and snake.y_pos == cell[1]:
self.loop()
# Initialize font and draw title and score text
pygame.font.init()
font = pygame.font.Font('./assets/Now-Regular.otf', 28)
score_text = 'Score: {}'.format(self.score)
score = font.render(score_text, True, Config['colors']['white'])
title = font.render('Snake Game', True, Config['colors']['white'])
title_rect = title.get_rect(center=(Config['game']['width'] / 2,
Config['game']['bumper_size'] /
2))
score_rect = score.get_rect(
center=(500 / 2, Config['game']['height'] -
Config['game']['bumper_size'] / 2))
self.display.blit(score, score_rect)
self.display.blit(title, title_rect)
pygame.display.update()
clock.tick(Config['game']['fps'])
class SnakeApp:
'''
Main class that keeps track of snakes, apples and the board.
All the Pygame magic happens here.
'''
windowWidth = 800
windowHeight = 600
player = 0
apple = 0
def __init__(self):
self._display_surf = None
self._image_surf = None
self._apple_surf = None
self._running = True
self.board = Board(self.windowWidth, self.windowHeight)
self.player = Player(3)
self.apple = Apple(5,5)
def print_debug(self):
'''
Method to print debug
I put this in its own method because this could change all the time
and I don't want to clutter the main execution code
'''
print("$$$$$$\nHola! ¿Cómo estás?")
print(self.player.x[0])
print(self.player.y[0])
print("$$$$$$\n")
def on_init(self):
pygame.init()
pygame.display.set_caption('No Step on Snek')
# surfaces
self._display_surf = pygame.display.set_mode((self.windowWidth,self.windowHeight), pygame.HWSURFACE)
self._image_surf = pygame.image.load("block.png").convert()
self._apple_surf = pygame.image.load("apple.png").convert()
# start running the game!
self._running = True
def on_event(self, event):
# Esc key to exit
if event.type == QUIT:
self._running = False
def on_loop(self):
self.player.update()
# does snake run into walls?
if(self.board.isPointOutsideBoard(self.player.x[0], self.player.y[0])):
print("Your snake ran into a wall or probably fell into a pit of lava! Wall collision:")
print("x[0] (" + str(self.player.x[0]) + "," + str(self.player.y[0]) + ")")
self._running = False
# does snake eat apple?
for i in range(0,self.player.length):
# collision needs to take step size and texture size into account
# my textures are 10x10, step size is 20, so step/2 is a good hit
# otherwise, sometimes the apples are eaten and the player isn't
# exactly matched up with the apple
if self.board.isCollision(self.apple.x,self.apple.y,self.player.x[i], self.player.y[i], self.player.step/2):
self.apple.x = randint(2,9) * self.player.step
self.apple.y = randint(2,9) * self.player.step
self.player.length = self.player.length + 1
# does snake collide with itself?
for i in range(2,self.player.length):
if self.board.isCollision(self.player.x[0],self.player.y[0],self.player.x[i], self.player.y[i], self.player.step - 5):
print("You lose! Collision: ")
print("x[0] (" + str(self.player.x[0]) + "," + str(self.player.y[0]) + ")")
print("x[" + str(i) + "] (" + str(self.player.x[i]) + "," + str(self.player.y[i]) + ")")
self._running = False
pass
def on_render(self):
self._display_surf.fill((0,0,0))
self.player.draw(self._display_surf, self._image_surf)
self.apple.draw(self._display_surf, self._apple_surf)
pygame.display.flip()
def on_cleanup(self):
pygame.quit()
def on_execute(self):
if self.on_init() == False:
self._running = False
while(self._running):
pygame.event.pump()
keys = pygame.key.get_pressed()
# move keys
if (keys[K_RIGHT]):
self.player.moveRight()
if (keys[K_LEFT]):
self.player.moveLeft()
if (keys[K_UP]):
self.player.moveUp()
if (keys[K_DOWN]):
self.player.moveDown()
# game flow control keys
if (keys[K_ESCAPE]):
self._running = False
# d is for debug to see wtf is going on
if (keys[K_d]):
self.print_debug()
self.on_loop()
self.on_render()
time.sleep(50.0 / 1000.0);
self.on_cleanup()
class App:
def __init__(self):
self._running = True
self._display = None
self._appleImage = None
self.gameSpeed = 0.12 # smaller value corresponds to faster speed
self.blockSize = 15 # pixel size: (0 to blockSize-1) by (0 to blockSize-1)
self.size = self.weight, self.height = self.blockSize * 50, self.blockSize * 30 # window pixel size: (0,0) is the top left starting point
self.reset()
def reset(self):
self._apple = Apple(self.blockSize * randint(1, self.weight // self.blockSize - 1), # column 0 is reserved for snake's starting point
self.blockSize * randint(0, self.height // self.blockSize - 1))
self._snake = Snake(0, self.blockSize * randint(0, self.height // self.blockSize - 1), self.blockSize)
self._snake.length = 1
self._game = Game()
def on_init(self):
pygame.init()
self._display = pygame.display.set_mode(self.size, pygame.HWSURFACE | pygame.DOUBLEBUF)
pygame.display.set_caption("Snake")
self._running = True
self._appleImage = pygame.image.load("apple.png").convert()
self._appleImage = pygame.transform.scale(self._appleImage, (self.blockSize, self.blockSize))
self._snakeImage = pygame.image.load("snake.png").convert()
self._snakeImage = pygame.transform.scale(self._snakeImage, (self.blockSize, self.blockSize))
def on_event(self, event):
if event.type == pygame.QUIT:
self._running = False
def on_loop(self):
self._snake.update()
# when the snake eats the apple
if self._game.Collision(self._apple.x, self._apple.y, self._snake.x[0], self._snake.y[0]):
self._apple.x = self.blockSize * randint(0, self.weight // self.blockSize - 1) # random apple x point
self._apple.y = self.blockSize * randint(0, self.height // self.blockSize - 1) # random apple y point
self._snake.grow()
self._snake.update()
for i in range(1, self._snake.length):
if self._game.Collision(self._snake.x[i], self._snake.y[i], self._snake.x[0], self._snake.y[0]) or \
self._game.Collision(-15, 15, self._snake.x[0], self._snake.y[0]):
self._game.Lost(self.blockSize, self._display)
if self._game.Restart() == False:
self._running = False
else: #restart the game (initialize all parameters)
self.reset()
def on_render(self):
self._display.fill((0, 0, 0)) # empty(initialize) the screen
self._apple.draw(self._display, self._appleImage)
self._snake.draw(self._display, self._snakeImage)
pygame.display.flip()
def on_cleanup(self):
pygame.quit()
def on_execute(self):
if self.on_init() == False:
self._running = False
while (self._running):
## keys = pygame.key.get_pressed() #get keys that are currently pressed down
for event in pygame.event.get():
self.on_event(event)
if (event.type == pygame.KEYDOWN): # get which keys were pressed down on that frame
if event.key == pygame.K_RIGHT:
self._snake.moveRight()
print("Right")
if event.key == pygame.K_LEFT:
self._snake.moveLeft()
print("Left")
if event.key == pygame.K_UP:
self._snake.moveUp()
print("Up")
if event.key == pygame.K_DOWN:
self._snake.moveDown()
print("Down")
if event.key == pygame.K_ESCAPE or event.key == pygame.K_q:
self._running = False
if event.key == pygame.K_p:
self._game.Pause()
self.on_loop()
self.on_render()
time.sleep(self.gameSpeed) # speed of the game
self.on_cleanup()
class Game:
def __init__(self):
pygame.init()
pygame.display.set_caption("ugly snake ")
pygame.mixer.init()
self.play_backround_music()
self.surface = pygame.display.set_mode((DX, DY))
self.surface.fill((255, 255, 255))
self.snake = Snake(self.surface, 1)
self.snake.draw()
self.apple = Apple(self.surface)
self.apple.draw()
# self.maze = Maze(self.surface)
# self.maze.draw_maze()
# self.maze_check = True
def bg_pic(self):
bg = pygame.image.load("resources/background.jpg")
self.surface.blit(bg, (0, 0))
def play_sound(self, sound):
sound = pygame.mixer.Sound(f"resources/{sound}.mp3")
pygame.mixer.Sound.play(sound)
def play_backround_music(self):
pygame.mixer.music.load("resources/bg_music_1.mp3")
pygame.mixer.music.play()
def increas_speed(self,current_speed):
global GAME_SPEED
GAME_SPEED = current_speed -0.1
def play(self):
self.bg_pic()
self.snake.walk()
self.apple.draw()
# self.maze.draw_maze()
self.display_score()
pygame.display.flip()
if self.is_collision(self.snake.x[0], self.snake.y[0], self.apple.x, self.apple.y):
self.play_sound("ding")
self.apple.move()
self.snake.increas_snake()
if self.snake.length % 2 == 0:
self.increas_speed(GAME_SPEED)
#
for i in range(2, self.snake.length):
if self.is_collision(self.snake.x[0], self.snake.y[0], self.snake.x[i], self.snake.y[i]):
self.game_over()
for y in range(DY):
if self.is_collision(self.snake.x[0], self.snake.y[0], 800, y):
self.game_over()
if self.is_collision(self.snake.x[0], self.snake.y[0], 0, y):
self.game_over()
for x in range(DX):
if self.is_collision(self.snake.x[0], self.snake.y[0], x, 800):
self.game_over()
if self.is_collision(self.snake.x[0], self.snake.y[0], x, 0):
self.game_over()
def game_over(self):
self.play_sound("crash")
raise Exception("Game Over")
def is_collision(self, x1, y1, x2, y2):
if x1 >= x2 and x1 < x2 + SIZE:
if y1 >= y2 and y1 < y2 + SIZE:
return True
return False
def display_score(self):
font = pygame.font.SysFont("ariel",20)
score = font.render(f"Score: {self.snake.length}", True, (255, 255, 255))
self.surface.blit(score, (100, 0))
def run(self):
running = True
pause = False
while running:
for event in pygame.event.get():
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
running = False
if event.key == K_UP:
self.snake.moveUp()
if event.key == K_DOWN:
self.snake.moveDown()
if event.key == K_LEFT:
self.snake.moveLeft()
if event.key == K_RIGHT:
self.snake.moveRight()
if event.key == K_RETURN:
pygame.mixer.music.play()
pause = False
self.reset_game()
elif event.type == QUIT:
running = False
try:
if not pause:
self.play()
except Exception as e:
self.show_game_over()
pause = True
time.sleep(GAME_SPEED)
def show_game_over(self):
self.bg_pic()
pygame.mixer.music.pause()
self.surface.fill((0, 0, 0))
font = pygame.font.SysFont('ariel', 40)
line1 = font.render(f"Game Over!! your score is {self.snake.length}", True, (255, 255, 255))
self.surface.blit(line1, (200, 300))
line2 = font.render(f"press escape to exit , Enter to play again", True, (255, 255, 255))
self.surface.blit(line2, (200, 350))
pygame.display.flip()
pass
def reset_game(self):
self.snake = Snake(self.surface, 1)
self.apple = Apple(self.surface)
global GAME_SPEED
GAME_SPEED = 1
pass
def game_loop(self):
clock = pygame.time.Clock()
snake = Snake(self.display)
apple = Apple(self.display)
x_movement = 0
y_movement = 0
self.score = 0
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
#print(event)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
x_movement = -Config['snake']['speed']
y_movement = 0
elif event.key == pygame.K_RIGHT:
x_movement = Config['snake']['speed']
y_movement = 0
elif event.key == pygame.K_DOWN:
y_movement = Config['snake']['speed']
x_movement = 0
elif event.key == pygame.K_UP:
y_movement = -Config['snake']['speed']
x_movement = 0
"""if event.type == pygame.KEYUP:
if event.key == pygame.K_UP:
y_movement = 0
x_movement = 0
elif event.key == pygame.K_DOWN:
y_movement = 0
x_movement = 0
elif event.key == pygame.K_RIGHT:
x_movement =0
y_movement = 0
elif event.key == pygame.K_LEFT:
x_movement = 0
y_movement = 0
"""
self.display.fill(Config['colors']['green'])
pygame.draw.rect(self.display, Config['colors']['black'], [
Config['game']['bumper_size'], Config['game']['bumper_size'],
Config['game']['height'] - Config['game']['bumper_size'] * 2,
Config['game']['width'] - Config['game']['bumper_size'] * 3
])
apple_rect = apple.draw()
snake.move(x_movement, y_movement)
snake_rect = snake.draw()
snake.draw_body()
#collision
bumper_x = Config['game']['width'] - Config['game']['bumper_size']
bumper_y = Config['game']['height'] - Config['game']['bumper_size']
if (snake.x_pos < Config['game']['bumper_size']
or snake.y_pos < Config['game']['bumper_size']
or snake.x_pos + Config['snake']['width'] > bumper_x
or snake.y_pos + Config['snake']['height'] > bumper_y):
self.game_loop()
if apple_rect.colliderect(snake_rect):
apple.appleDisplay()
self.score += 1
snake.eat()
if len(snake.body) >= 1:
for cell in snake.body:
if snake.x_pos == cell[0] and snake.y_pos == cell[1]:
self.game_loop()
pygame.font.init()
font = pygame.font.Font('./Now-Regular.otf', 28)
score_text = 'Score: {}'.format(self.score)
score = font.render(score_text, True, Config['colors']['white'])
title = font.render('snake - Vikram', True,
Config['colors']['white'])
title_rect = title.get_rect(center=(Config['game']['width'] / 2,
Config['game']['bumper_size'] /
2))
score_rect = score.get_rect(
center=(500 / 2, Config['game']['height'] -
Config['game']['bumper_size'] / 2))
self.display.blit(score, score_rect)
#self.display.blit(title, title_rect)
pygame.display.update()
clock.tick(Config['game']['fps'])
for event in pygame.event.get():
if event.type == pygame.QUIT:
playing = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_w or event.key == pygame.K_UP:
mySnake.setUp()
if event.key == pygame.K_s or event.key == pygame.K_DOWN:
mySnake.setDown()
if event.key == pygame.K_a or event.key == pygame.K_LEFT:
mySnake.setLeft()
if event.key == pygame.K_d or event.key == pygame.K_RIGHT:
mySnake.setRight()
screen.fill(grey)
if mode == 1:
mode = mySnake.draw(screen)
myApple.draw(screen)
if mySnake.x == myApple.x and mySnake.y == myApple.y:
x = random.randint(0, 49)
y = random.randint(0, 49)
myApple = Apple(x, y)
mySnake.size += 3
if mode == 2:
screen.blit(text, (250, 250))
pygame.display.flip()
pygame.quit()
def game_loop_2p(self):
"""Game loop for 2 player mode"""
snake_length = 6
snake1 = Snake(snake_length, color=GREEN, game=self, name="Player 1")
snake2 = Snake(snake_length, color=BLUE, game=self, img=SNAKE_HEAD_2, name="Player 2", offset_y=20)
apple = Apple(APPLE_SIZE, game=self)
def game_reset():
nonlocal snake1, snake2, apple
snake1 = Snake(snake_length, color=GREEN, game=self, name="Player 1")
snake2 = Snake(snake_length, color=BLUE, game=self, img=SNAKE_HEAD_2, name="Player 2", offset_y=20)
apple = Apple(APPLE_SIZE, game=self)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.game_exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT and snake1.direction != 'RIGHT' and not snake1.turned:
snake1.turn('LEFT')
elif event.key == pygame.K_RIGHT and snake1.direction != 'LEFT' and not snake1.turned:
snake1.turn('RIGHT')
elif event.key == pygame.K_UP and snake1.direction != 'DOWN' and not snake1.turned:
snake1.turn('UP')
elif event.key == pygame.K_DOWN and snake1.direction != 'UP' and not snake1.turned:
snake1.turn('DOWN')
elif event.key == pygame.K_a and snake2.direction != 'RIGHT' and not snake2.turned:
snake2.turn('LEFT')
elif event.key == pygame.K_d and snake2.direction != 'LEFT' and not snake2.turned:
snake2.turn('RIGHT')
elif event.key == pygame.K_w and snake2.direction != 'DOWN' and not snake2.turned:
snake2.turn('UP')
elif event.key == pygame.K_s and snake2.direction != 'UP' and not snake2.turned:
snake2.turn('DOWN')
self.display.fill(WHITE)
pygame.draw.rect(self.display, BLACK, [0, self.height, self.width, PANEL_HEIGHT])
self.message("Score: " + str(snake1.score), GREEN, h_align='left', v_align='bottom', off_set_y=20)
self.message("Score: " + str(snake2.score), BLUE, h_align='right', v_align='bottom', off_set_y=20)
apple.draw()
snake1.draw()
snake2.draw()
snake1.go()
snake2.go()
if snake1.hit_wall() or snake1.hit_tail():
snake1.die = True
if snake2.hit_wall() or snake2.hit_tail():
snake2.die = True
if snake1.die and snake2.die:
self.show_score(snake1, snake2, game_reset)
pygame.display.update()
if snake1.eat(apple) or snake2.eat(apple):
apple = Apple(APPLE_SIZE, game=self)
CLOCK.tick(FPS)
