Beispiel #1
0
def playAI(numGames, numSteps, model):
    sum = 0
    highScore = 0
    i = 1
    for _ in range(numGames):
        game = SnakeGame()
        for _ in range(numSteps):
            angle, appleDV_Normalized, snakeDV_Normalized = angleSnakeApple(
                game.snake.positions, game.apple.position)
            currentDV, isFrontBlocked, isLeftBlocked, isRightBlocked = blockedDirectionsTrain(
                game.snake.positions, game.apple.position)
            X = [
                isLeftBlocked, isFrontBlocked, isRightBlocked,
                appleDV_Normalized[0], snakeDV_Normalized[0],
                appleDV_Normalized[1], snakeDV_Normalized[1]
            ]
            # X = [isLeftBlocked, isFrontBlocked, isRightBlocked, angle]
            X = np.array(X).reshape(-1, len(X))
            predicted_direction = np.argmax(np.array(model.predict(X))) - 1
            # print(predicted_direction)
            updated_direction, button_direction = directionVector(
                game.snake.positions, angle, predicted_direction)

            if isBlocked(game.snake.positions, currentDV) == 1:
                # print(X)
                # print(predicted_direction)
                break

            _, _, _ = game.run_game(buttonDirection=button_direction)
        print("GAME " + str(i) + " SCORE = " + str(game.score))
        sum += game.score
        i += 1
        if (game.score > highScore): highScore = game.score
    return sum // numGames, highScore
	def __init__(self, name, snake, FPS=5, scale=20, LIVES=3):
		SnakeGame.__init__(self, name)
		self.snake = snake
		self.FPS = FPS
		self.scale = scale
		self.lives_remaining = LIVES
		self.score = 0
Beispiel #3
0
    def __init__(self,
                 width: int = 20,
                 height: int = 20,
                 speed: int = 10) -> None:
        self.WINDOW_SIZE = 640

        self.grid_width = width
        self.grid_height = height
        self.speed = speed

        self.screen = pygame.display.set_mode(
            (self.WINDOW_SIZE, self.WINDOW_SIZE))
        self.game = SnakeGame(width, height)

        self.cell_width = 32
Beispiel #4
0
def main():
    args = get_args()

    # Convert the walls from input format into coordinate tuples.
    walls = set()
    for i in range(0, len(args.walls) // 2, 2):
        walls.add((args.walls[i], args.walls[i + 1]))

    game = SnakeGame(board_size=tuple(args.board_size),
                     walls=walls,
                     random_seed=args.random_seed)

    GameIO(game=game,
           speed=args.speed,
           player_name=args.player_name,
           score_file=args.score_file)
Beispiel #5
0
"""
Famous snake game
"""

from settings import *
from game import SnakeGame

if __name__ == "__main__":

    game = SnakeGame()
    game.run()
Beispiel #6
0
def play():
    for i in range(100000):
        snake = SnakeGame()
Beispiel #7
0
def main(stdscr):
    """Entry point"""
    SnakeGame(stdscr).start()
Beispiel #8
0
        self.sh = int(self.sh / 2)
        self.sw = int(self.sw / 2)
        self.drawer = curses.newwin(self.sh + 1, self.sw + 1, 0, 0)
        self.drawer.keypad(1)

    def start(self):
        self.game.init(self.sw, self.sh)
        self.drawer.timeout(100)
        self.run()

    def run(self):
        key = curses.KEY_RIGHT
        while True:
            next_key = self.drawer.getch()
            key = key if next_key == -1 else next_key

            self.game.move(key)

            if self.game.get_state():
                self.game.draw()
            else:
                curses.endwin()
                quit()


driver = Driver()
driver.game = SnakeGame(driver.drawer)
driver.game.food_len = 5
driver.game.number_of_snakes = 1
driver.start()
Beispiel #9
0
            if g.tick():
                time.sleep(1 / ((int(g.score / 10 + 1)) * 10))
            else:
                self.running = False

    def start_loop(self):
        t = threading.Thread(target=self._loop, args=(), daemon=True)
        t.start()
        return t


if __name__ == '__main__':
    size = [800, 600]
    screen = pygame.display.set_mode(size)
    g = SnakeGame(size[1] // 10, size[0] // 10)

    rrunning = True
    while rrunning:
        g.initialize()
        g.place_food()
        game_surf = pygame.Surface(size)
        font = pygame.font.SysFont('roboto', 16)

        gt = BoardLogic(g)
        gt.start_loop()

        running = True
        while running:
            if not gt.running:
                running = False
Beispiel #10
0
    #delete all frames from the previous training
    print("removing all frames from previous training")
    n_files = len([name for name in os.listdir(target_folder)])
    cntr = 0
    for i in glob.glob(f"{target_folder}/*jpg"):
        sys.stdout.write('\r')
        sp = cntr/((n_files-1)/100)
        tp = int(sp/4)
        sys.stdout.write("[%-25s] %d%%" % ('='*tp, sp)) #25s=25spaces
        sys.stdout.flush()
        os.remove(i)
        cntr += 1
    print("removed")

    env = SnakeGame()
    agent = Agent(gamma = 0.99, epsilon = 1.0,  batch_size = 64, n_actions = 4,eps_end = 0.01, input_dims = [16], lr = 0.003)
    scores, eps_history, avg_scores, frames = [] , [] , [] ,[] #frames will not be in use
    n_games = n_episodes

    for i in range(n_games):
        score = 0
        step = 0
        done = False
        observation = env.reset()
        # frames.append(env.animate(i,step,score))
        snake_len = len(env.snake)
        frame = env.animate(i,step,score,snake_len)
        frame.save(f"{target_folder}/ep{i}step{step}.jpg","jpeg")

        while not done:
Beispiel #11
0
from game import SnakeGame
from inputs import KeyboardListener
from game_input_dispatcher import GameInputDispatcher
from plotter import GamePlotter

import time

game = SnakeGame()
keyboard = KeyboardListener()
plotter = GamePlotter(game)

input_dispatcher = GameInputDispatcher(game)

keyboard.subscribe(input_dispatcher.move_snake)
keyboard.subscribe(input_dispatcher.new_game)

game.new_game()

while True:
    time.sleep(.5 / game.speed)
    game.move_snake()

    if game.alive:
        plotter.plot()
    else:
        plotter.game_over()
Beispiel #12
0
from game import SnakeGame

GRID_SIZE = 20

game = SnakeGame.SnakeGame(GRID_SIZE)
game.initialize()
game.run()

Beispiel #13
0
class GUI:
    def __init__(self,
                 width: int = 20,
                 height: int = 20,
                 speed: int = 10) -> None:
        self.WINDOW_SIZE = 640

        self.grid_width = width
        self.grid_height = height
        self.speed = speed

        self.screen = pygame.display.set_mode(
            (self.WINDOW_SIZE, self.WINDOW_SIZE))
        self.game = SnakeGame(width, height)

        self.cell_width = 32

    def _draw_lines(self) -> None:
        """ Отрисовка линий """

        for x in range(self.grid_width):
            x = x * self.cell_width
            pygame.draw.line(self.screen, pygame.Color('black'), (x, 0),
                             (x, self.WINDOW_SIZE))

        for y in range(self.grid_height):
            y = y * self.cell_width
            pygame.draw.line(self.screen, pygame.Color('black'), (0, y),
                             (self.WINDOW_SIZE, y))

    def _draw_grid(self) -> None:
        """ Отрисовка поля """
        def draw_rectangle(color: pygame.Color, row: int, col: int) -> None:
            assert 0 <= col <= self.grid_height
            assert 0 <= row <= self.grid_width

            pygame.draw.rect(self.screen, color,
                             (col * self.cell_width, row * self.cell_width,
                              self.cell_width, self.cell_width))

        for row in range(self.grid_height):
            for col in range(self.grid_width):
                color = self.COLORS[self.game.grid[row][col]]

                draw_rectangle(color, row, col)

        draw_rectangle(pygame.Color('green'), *self.game.snake.head)

        self._draw_lines()

    def _show_gameover(self, text: str) -> None:
        """ Показать текст об окончании игры """

        font = pygame.font.Font(None, 25)
        text = font.render(text, True, pygame.Color('white'),
                           pygame.Color('black'))

        textRect = text.get_rect()
        textRect.center = (self.WINDOW_SIZE // 2, self.WINDOW_SIZE // 2)

        self.screen.blit(text, textRect)
        pygame.display.update()

    def _change_direction_by_event(self, event: pygame.event) -> None:
        """ Поменять направление движения змеи """

        direction = None

        if event.key == pygame.K_RIGHT:
            direction = Snake.RIGHT_DIRECTION
        elif event.key == pygame.K_LEFT:
            direction = Snake.LEFT_DIRECTION
        elif event.key == pygame.K_UP:
            direction = Snake.UP_DIRECTION
        elif event.key == pygame.K_DOWN:
            direction = Snake.DOWN_DIRECTION

        self.game.change_direction(direction)

    def run(self) -> None:
        """ Начать игру """

        pygame.init()
        clock = pygame.time.Clock()
        pygame.display.set_caption('Snake')
        self.screen.fill(pygame.Color('white'))
        running = True

        self._draw_grid()

        while running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False

                elif event.type == pygame.KEYDOWN:
                    self._change_direction_by_event(event)

            error = self.game.step()

            if not error is None:
                self._show_gameover(error)

            else:
                self._draw_grid()
                pygame.display.flip()
                clock.tick(self.speed)

        pygame.quit()

    COLORS = {
        0: pygame.Color('black'),
        1: pygame.Color('white'),
        2: pygame.Color('red'),
        3: pygame.Color('green')
    }
	def __init__(self, name, server, min_players, FPS=5, scale=20):
		SnakeGame.__init__(self, name, min_players)
		self.FPS = FPS
		self.scale = scale
		self.server = server
		self.client_snake = {}
Beispiel #15
0
from game import SnakeGame

if __name__ == "__main__":
    SnakeGame.start()
Beispiel #16
0
                                        len(mean_scores) + 1),
                                  mean_scores,
                                  '-o',
                                  alpha=0.8)

            plt.pause(0.1)


if __name__ == '__main__':
    scores = []
    mean_scores = []
    total_score = 0
    maximum_score = 11

    screen = UI()
    game = SnakeGame(screen)
    screen.set_game(game)

    model = DQN(11, 256, 3)
    train = QTrain(model, lr=LR, gamma=GAMMA)
    model = train.load_checkpoint()
    agent = Agent(model, train, game)

    # training loop
    while True:
        current_state = agent.get_state()
        next_action = agent.get_action(current_state)

        game_over, score, reward = game.play_step(next_action)
        new_state = agent.get_state()
        agent.train_over_sample(current_state, next_action, reward, new_state,
Beispiel #17
0
from game import SnakeGame

if __name__ == "__main__":
    snake = SnakeGame()
    snake.main_loop()
	def __init__(self, name, client, min_players, FPS=5, scale=20):
		SnakeGame.__init__(self, name, min_players)
		self.FPS = FPS
		self.scale = scale
		self.client = client
Beispiel #19
0
import pygame

window_dimensions = (500, 500)
pixel_mult = 6

pygame.init()
screen = pygame.display.set_mode(window_dimensions)
done = False

clock = pygame.time.Clock()

snake_color = (0, 250, 0)
apple_color = (250, 0, 0)

game = SnakeGame(
    (window_dimensions[0] / pixel_mult, window_dimensions[1] / pixel_mult))

while not done:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            done = True

    pressed = pygame.key.get_pressed()

    if pressed[pygame.K_q]:
        done = True

    if pressed[pygame.K_x]:
        game.cheat_eat_apple()

    heading = None
# Dumb AI, randomly choice from possible actions
import sys
sys.path.insert(0, '~/Dropbox/SideProjects/snake')

import random
from game import SnakeGame


class AIRandomWalk:
    def __init__(self):
        self.ai = None

    def getAction(self, state):
        return random.choice(state.getPossibleActions())


if __name__ == '__main__':
    game = SnakeGame.Game(ai_object=AIRandomWalk)
    print game.run()