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 ' +