def testSnakeLength(self):
game_map = Map2D(2, 1)
snake = Snake(game_map, 0, 0, Direction.X_POSITIVE)
self.assertEqual(len(snake), 1)
Food(game_map)
snake.move()
self.assertEqual(len(snake), 2)
def testMoveResultHitUnknownObject(self):
game_map = Map2D(2, 1)
snake = Snake(game_map, 0, 0, Direction.X_POSITIVE)
game_map.put('some_object', 1, 0)
with self.assertRaises(RuntimeError) as context:
snake.move()
self.assertIn('Blocking object unknown type', str(context.exception))
def testMoveResultAteFood(self):
game_map = Map2D(2, 1)
snake = Snake(game_map, 0, 0, Direction.X_POSITIVE)
Food(game_map)
self.assertEqual(snake.move(), Snake.MoveResult.ATE_FOOD)
self.assertIs(game_map.peek(0, 0), snake)
self.assertIs(game_map.peek(1, 0), snake)
self.assertEqual(snake.head_pos(), (1, 0))
def __init__(self):
self._running = True
self._display_surf = None
self.size = self.width, self.height = WIDTH, HEIGHT
self.clock = None
self.snake = Snake()
self.fruit = Fruit()
self.pause = False
self.moves = 0
self.frames = 11
def testMovementUnsuccessfulDirectionChange(self):
game_map = Map2D(3, 3)
snake = Snake(game_map, 0, 1, Direction.X_POSITIVE)
snake.move()
snake.set_direction(Direction.X_NEGATIVE)
snake.move()
self.assertEqual(game_map.peek(2, 1), snake)
def __init__(self,
id_,
nn_structure,
width,
height,
screen,
step=10,
length=3):
self.id = id_
self.fitness = 0
self.width = width
self.height = height
self.screen = screen
# randomize snake position / direction ?
self.snake = Snake(self.width // 2,
self.height // 2,
step, (self.width, self.height),
self.screen,
length=length)
self.apple = Apple(step, (self.width, self.height), self.screen,
self.snake)
self.base_length = length
self.nn_structure = nn_structure
self.brain = nn.NeuralNetwork(nn_structure)
self.saved = False
def __init__(self):
self.snake = Snake.Snake()
self.apple = Apple.Apple()
self.REWARD_NOTHING = -1
self.REWARD_GET_APPLE = 30
self.REWARD_COLLIDE = -100
self.wall = Util.SCREEN_HEIGHT / Util.BLOCK_SIZE
self.padding = 9
def testReturnsHeadPosition(self):
game_map = Map2D(3, 3)
snake = Snake(game_map, 1, 2, Direction.X_POSITIVE)
self.assertEqual(snake.head_pos(), (1, 2))
def testFailsToPutSnakeOnFilledPosition(self):
game_map = Map2D(3, 3)
game_map.put('blocker', 1, 2)
with self.assertRaises(ValueError) as context:
Snake(game_map, 1, 2, Direction.X_POSITIVE)
self.assertIn('is blocked by', str(context.exception))
def test_move_snake_down_from_initial_position(self):
snake = Snake()
snake.move('down')
self.assertEqual(snake.positions, [[5, 4], [5, 5], [5, 6]])
self.assertEqual(snake.direction, 'down')
def test_move_horizontal_snake_down(self):
snake = Snake([[4, 3], [5, 3], [6, 3]])
snake.move('down')
self.assertEqual(snake.positions, [[5, 3], [6, 3], [6, 4]])
self.assertEqual(snake.direction, 'down')
def testPutsSnakeOnEmptyPosition(self):
game_map = Map2D(3, 3)
snake = Snake(game_map, 1, 2, Direction.X_POSITIVE)
self.assertEqual(game_map.peek(1, 2), snake)
https://codingandcommunity.org/
Loosely based off of this tutorial:
https://www.youtube.com/watch?v=rrOqlfMujqQ&ab_channel=ChristianThompson
July 2019
"""
import turtle # Graphics module
import time # For delay
import random # For placing fruits
from snake_game import Game, Snake, Food, Scoreboard # Helpers
# Initialize helper objects
game = Game(600, 600, wn_color='grey', delay=0.05)
snake = Snake(game)
snake.set_direction("stop")
food = Food(game)
scoreboard = Scoreboard(game)
# Counter for tracking the player's score
score = 0
'''
Step 1: Write function to set where the snake will move
Do so with snake.set_direction(dir) where dir is a String and one of:
["up", "down", "left", "right", "stop"]
'''
# TODO write functions to set movement direction
def test_move_snake_right_from_initial_position(self):
snake = Snake()
snake.move('right')
self.assertEqual(snake.positions, [[5, 4], [5, 5], [6, 5]])
self.assertEqual(snake.direction, 'right')
def testMoveSnakeOnCircularPath(self):
game_map = Map2D(2, 2)
snake = Snake(game_map, 0, 0, Direction.X_POSITIVE)
Food(game_map)
Food(game_map)
Food(game_map)
snake.move()
snake.set_direction(Direction.Y_POSITIVE)
snake.move()
snake.set_direction(Direction.X_NEGATIVE)
snake.move()
snake.set_direction(Direction.Y_NEGATIVE)
self.assertEqual(snake.move(), Snake.MoveResult.MOVED)
self.assertEqual(snake.head_pos(), (0, 0))
self.assertEqual(snake.end_pos(), (1, 0))
def testMoveResultHitSnake(self):
game_map = Map2D(2, 1)
snake = Snake(game_map, 0, 0, Direction.X_POSITIVE)
Snake(game_map, 1, 0, Direction.X_POSITIVE)
self.assertEqual(snake.move(), Snake.MoveResult.HIT_SNAKE)
self.assertIs(game_map.peek(0, 0), snake)
July 2019
"""
import turtle # Graphics module
import time # For delay
import random # For placing fruits
from snake_game import Game, Snake, Food, Scoreboard
# Resource locations on disk
jungle_bg = "C:/Users/ganzk/Desktop/rise_high/python/snake/demo/bg.gif"
apple = "C:/Users/ganzk/Desktop/rise_high/python/snake/demo/apple.gif"
high_scores_path = "C:/Users/ganzk/Desktop/rise_high/python/snake/demo/high_scores.txt"
# Initialize helper objects
game = Game(512, 512, wn_bg=jungle_bg, delay=0.1)
snake = Snake(game, color="white")
food = Food(game, color="red")
scoreboard = Scoreboard(game)
# Counter for tracking the player's score
score = 0
# List of colors and index to track iteration
color_list = ["red", "orange", "yellow", "green", "blue", "violet"]
color_index = 0
high_score = None
# Load in high score
with open(high_scores_path) as file:
for line in file:
high_score = int(line.strip())
def testMoveYNegative(self):
game_map = Map2D(3, 3)
snake = Snake(game_map, 1, 1, Direction.Y_NEGATIVE)
self.assertEqual(snake.move(), Snake.MoveResult.MOVED)
self.assertIs(game_map.peek(1, 0), snake)
self.assertIsNone(game_map.peek(1, 1))
def test_should_keep_direction_when_trying_to_move_down_if_going_up(self):
positions = [[5, 5], [5, 4], [5, 3]]
snake = Snake(initial_positions=positions, direction='up')
snake.move('down')
self.assertEqual(snake.positions, [[5, 4], [5, 3], [5, 2]])
self.assertEqual(snake.direction, 'up')
def test_should_keep_direction_when_trying_to_move_up_if_going_down(self):
initial_positions = [[5, 3], [5, 4], [5, 5]]
snake = Snake()
snake.move('up')
self.assertEqual(snake.positions, [[5, 4], [5, 5], [5, 6]])
self.assertEqual(snake.direction, 'down')
def test_should_keep_direction_when_trying_to_move_left_if_going_right(self):
positions = [[4, 3], [5, 3], [6, 3]]
snake = Snake(initial_positions=positions, direction='right')
snake.move('left')
self.assertEqual(snake.positions, [[5, 3], [6, 3], [7, 3]])
self.assertEqual(snake.direction, 'right')
def testReturnsEndPosition(self):
game_map = Map2D(2, 1)
snake = Snake(game_map, 1, 0, Direction.X_NEGATIVE)
Food(game_map)
snake.move()
self.assertEqual(snake.end_pos(), (1, 0))
def test_move_snake_up(self):
snake = Snake([[5, 5], [5, 4], [5, 3]], direction='up')
snake.move('up')
self.assertEqual(snake.positions, [[5, 4], [5, 3], [5, 2]])
self.assertEqual(snake.direction, 'up')
def testHeadPositionIsCorrectAfterMove(self):
game_map = Map2D(3, 3)
snake = Snake(game_map, 1, 1, Direction.X_POSITIVE)
snake.move()
self.assertEqual(snake.head_pos(), (2, 1))
flatten = lambda l: [item for sublist in l for item in sublist]
def get_state(grid_size, snake_location, state, alea=False):
state = []
for key, value in enumerate(state_control):
state.append(value)
return state
nb_cases = 20
display = True
# Initialisation du jeu
snake = Snake(nb_cases, display)
grid_size = nb_cases + 2
agent = Trainer(allowed_actions=snake.get_actions_set(),
name='SnakeV1',
state_size=6)
reward = 0
bestScore = 0
iteration = 0
lastTotalReward = 0
while 1:
# 30 FPS
#time.sleep(0.033)
score = int(snake.get_score())
def testMoveXPositive(self):
game_map = Map2D(3, 3)
snake = Snake(game_map, 1, 1, Direction.X_POSITIVE)
self.assertEqual(snake.move(), Snake.MoveResult.MOVED)
self.assertIs(game_map.peek(2, 1), snake)
self.assertIsNone(game_map.peek(1, 1))
def test_move_horizontal_snake_up(self):
snake = Snake([[4, 3], [5, 3], [6, 3]], direction='right')
snake.move('up')
self.assertEqual(snake.positions, [[5, 3], [6, 3], [6, 2]])
self.assertEqual(snake.direction, 'up')
def testMoveInUndefinedDirection(self):
game_map = Map2D(1, 1)
snake = Snake(game_map, 0, 0, 'not_a_direction')
with self.assertRaises(RuntimeError) as context:
snake.move()
self.assertIn('Invalid direction', str(context.exception))
def initialization(self):
del self.snake
del self.apple
self.snake = Snake.Snake()
self.apple = Apple.Apple()
def testMoveResultHitWall(self):
game_map = Map2D(1, 1)
snake = Snake(game_map, 0, 0, Direction.Y_NEGATIVE)
self.assertEqual(snake.move(), Snake.MoveResult.HIT_WALL)
from snake_game import Snake
import time
import random
snake = Snake(20, True)
debug = False
best_score = 0
while 1:
time.sleep(0.03)
if(debug):
move = snake.do_move(0)
else:
move = snake.do_move(random.randint(0,4))
print(move)
if(move['reward'] < 0):
snake.reset()
elif(snake.get_score() > best_score):
best_score = snake.get_score()
from turtle import Screen
import time
from snake_game import Snake
from food import Food
from scoreboard import Scoreboard
screen = Screen()
screen.screensize(canvheight=400, canvwidth=500)
screen.bgcolor("black")
screen.title("Snake Game")
screen.tracer(0)
snake = Snake()
food = Food()
scoreboard = Scoreboard()
screen.listen()
screen.onkey(snake.move_up, "Up")
screen.onkey(snake.move_left, "Left")
screen.onkey(snake.move_right, "Right")
screen.onkey(snake.move_down, "Down")
while snake.game_state:
screen.update()
time.sleep(0.2)
print(screen.canvheight)
class App:
'''
Main App for game
'''
def __init__(self):
self._running = True
self._display_surf = None
self.size = self.width, self.height = WIDTH, HEIGHT
self.clock = None
self.snake = Snake()
self.fruit = Fruit()
self.pause = False
self.moves = 0
self.frames = 11
def on_init(self):
pygame.init()
self._display_surf = pygame.display.set_mode(
self.size, pygame.HWSURFACE | pygame.DOUBLEBUF)
self._running = True
self.clock = pygame.time.Clock()
def on_event(self, event):
# Quit game
if event.type == pygame.QUIT:
self._running = False
# Change direction of snake
if event.type == pygame.KEYDOWN:
if event.key == K_UP:
# Increase speed of game
if self.frames < 1000000000:
self.frames *= 10
elif event.key == K_DOWN:
# Decrease speed of game
if self.frames > 10:
self.frames /= 10
elif event.key == K_p:
self.pause = not self.pause
elif event.key == K_q:
self.on_cleanup()
def on_loop(self, model_num):
self.snake.alive = self.snake.collision(self.snake.position[0])
if self.snake.alive is False:
return
if self.snake.eat(self.fruit) is True:
# Adjust fitness, reset move counter
fitness[model_num] += 150
score[model_num] += 1
self.moves = 0
self.snake.update()
if check_if_closer(self.snake, self.fruit):
# Reward snake for moving towards fruit
fitness[model_num] += 10
self.moves += 1
def on_render(self, model_num):
self._display_surf.fill((0, 124, 0))
# Fill every other space to create a multi color grid
for i in range(0, int(GRID_D)):
for j in range(0, int(GRID_D)):
if (i + j) % 2 == 0:
block = pygame.Rect(
((j * BLOCK_W, i * BLOCK_H), (BLOCK_W, BLOCK_H)))
pygame.draw.rect(self._display_surf, (0, 200, 0), block)
# Draw sanke and fruit
self.fruit.draw(self._display_surf)
self.snake.draw(self._display_surf)
pygame.display.set_caption("Gen: " + str(generation) + " Model: " +
str(model_num) + " Score: " +
str(self.snake.score) + " Tick " +
str(self.frames))
pygame.display.update()
def on_cleanup(self):
pygame.quit()
sys.exit()
def on_execute(self, i):
if self.on_init() == False:
self._running = False
while (self._running):
for event in pygame.event.get():
self.on_event(event)
self.snake.direction = predict_direction(self.snake, self.fruit, i)
# Checks if game is paused
if self.pause is False:
self.on_loop(i)
self.on_render(i)
self.clock.tick(self.frames)
# Reset when snake dies
if self.snake.alive == False or self.moves == MAX_MOVES:
print(int(self.snake.score))
self.snake.reset()
self.fruit.random_generate()
self.moves = 0
# Print fitness
print(fitness[i])
break
# Clean up and print score
# self.on_cleanup()
print(int(self.snake.score))
def run(weights,
number_of_hidden_layers,
node_for_first_layer,
node_for_hidden_layer,
node_for_last_layer,
max_steps,
board_size=None,
draw=False,
generation=None):
snake = Snake(board_size=board_size, generation=generation)
score = 0
game_score = 0
direction = 0
same_direction = 0
left_collision, right_collision, front_collision, angle, distance = snake.return_variables(
)
network = Network(number_of_hidden_layers, node_for_first_layer,
node_for_hidden_layer, node_for_last_layer, weights)
if draw:
snake.init_draw()
snake.start_game()
steps = 0
while steps < max_steps:
if not snake.playing:
break
# last_distance = distance
last_score = game_score
last_direction = direction
network.set_first_layer([
left_collision, right_collision, front_collision, angle, distance
])
output = network.calculate_output()
if output[0] >= output[1]:
if output[0] >= output[2]:
left_collision, right_collision, front_collision, angle, distance = snake.move(
"left")
direction = 0
else:
left_collision, right_collision, front_collision, angle, distance = snake.move(
"forward")
direction = 2
elif output[1] >= output[2]:
left_collision, right_collision, front_collision, angle, distance = snake.move(
"right")
direction = 1
else:
left_collision, right_collision, front_collision, angle, distance = snake.move(
"forward")
direction = 2
game_score = snake.score
if game_score > last_score:
score += 1
steps = 0
if last_direction == direction:
same_direction += 1
else:
same_direction = 0
if same_direction > board_size:
score = 0
snake.playing = False
if draw:
snake.draw_game()
sleep(0.02)
steps += 1
return score
]
return flatten(get_grille(game, x, y))
def get_grille(game, x, y):
grille = [[0] * int(game.width / 10) for i in range(int(game.height / 10))]
grille[x][y] = 1
return grille
# NE PAS CHANGER CETTE VARIABLE
case_size = 20
size = 10
# Initialisation du jeu
game = Snake(height=case_size * size, width=case_size * size)
agent = Trainer(allowed_actions=p.getActionSet(),
height=game.height,
width=game.width)
p.init()
reward = 0.0
nb_steps = 10000000000000000
bestScore = 0
for i in range(nb_frames):
if (p.score() > bestScore):
bestScore = int(p.score())
print('New Best Score : ' + str(bestScore) + ' a ' +
