summaryrefslogtreecommitdiff
path: root/snake.py
blob: a977de02b6c4541303d3790cf21784949ca8ce16 (about) (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
from __future__ import division
import random

from common import *

import pygame
pygame.init()
from pygame.locals import *

class SnakeEngine(object):
    EDGE_COLOR = (255, 255, 255)
    EDGE_WIDTH = 1

    def __init__(self, rows, columns, n_apples, width=800, height=600, fullscreen=False):
        super(SnakeEngine, self).__init__()
        flags = 0
        if fullscreen:
            flags |= pygame.FULLSCREEN
        self.screen = pygame.display.set_mode((width, height), flags)

        self.width = width
        self.height = height

        self.bots = {}

        self.new_game(rows, columns, n_apples)

    def new_game(self, rows, columns, n_apples):
        self.board = [[Squares.EMPTY for x in xrange(columns)] for y in xrange(rows)]
        for i in xrange(n_apples):
            x = random.randint(0, columns - 1)
            y = random.randint(0, rows - 1)
            self.board[y][x] = Squares.APPLE

    def add_bot(self, name, bot):
        """
        A bot is a callable object, with this method signature:
            def bot_callable(
                board=[[cell for cell in row] for row in board],
                position=(snake_x, snake_y)
                ):
                return random.choice('RULD')
        """
        self.bots[name] = bot

    def remove_bot(self, name):
        del self.bots[name]

    def draw_board(self):
        rows = len(self.board)
        assert rows > 0
        columns = len(self.board[0])

        board_aspect = columns / rows
        screen_aspect = self.width / self.height
        if board_aspect > screen_aspect:
            # restrict width
            width = self.width
            height = width / board_aspect
        else:
            # restrict height
            height = self.height
            width = height * board_aspect

        xscale = width / columns
        yscale = height / rows

        for y, row in enumerate(self.board):
            for x, cell in enumerate(row):
                left = int(x * xscale)
                top = int(y * yscale)
                w = int((x + 1) * xscale) - left
                h = int((y + 1) * yscale) - top
                r = Rect(left, top, w, h)
                pygame.draw.rect(self.screen, self.EDGE_COLOR, r,
                                 self.EDGE_WIDTH)

    def run(self):
        self.draw_board()
        pygame.display.flip()

if __name__ == '__main__':
    from bots import random_bot

    game = SnakeEngine(8, 16, 10)
    game.add_bot('Bob', random_bot)
    game.run()