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 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 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 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 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 testMoveResultHitWall(self):
game_map = Map2D(1, 1)
snake = Snake(game_map, 0, 0, Direction.Y_NEGATIVE)
self.assertEqual(snake.move(), Snake.MoveResult.HIT_WALL)
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 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 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_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 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 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)
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')
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)
print("#"*10)
snake.move()
print("#" * 10)
#detect collision with food
if snake.head.distance(food) < 15:
food.set_val()
scoreboard.add_point()
snake.add_to_tail()
#detect collision with wall
if abs(snake.head.xcor()) >= screen.canvwidth-20:
scoreboard.reset()
snake.reset()
elif abs(snake.head.ycor()) >= screen.canvheight:
scoreboard.reset()
snake.reset()
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 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 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 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))
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
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')
