Ejemplo n.º 1
0
Archivo: game.py Proyecto: 0b11stan/lab
 def __init__(self, player_x, player_o, players_interface):
     self.grid = Grid()
     self.player_x = player_x
     self.player_o = player_o
     self.pi = players_interface
     self.current_player = None
     self.current_player = player_x
Ejemplo n.º 2
0
    def test_serialize(self):
        g = Grid(4, 3)
        level_dict = g.serialize_level()

        print(level_dict)
        level_json = json.dumps(level_dict)
        print(level_dict[1][1])
Ejemplo n.º 3
0
Archivo: game.py Proyecto: 0b11stan/lab
class Game:
    def __init__(self, player_x, player_o, players_interface):
        self.grid = Grid()
        self.player_x = player_x
        self.player_o = player_o
        self.pi = players_interface
        self.current_player = None
        self.current_player = player_x

    def get_switched_player(self):
        return self.player_o if self.current_player == self.player_x else self.player_x

    def play(self):
        (row, col) = self.pi.choose_cell(self.current_player, self.player_x, self.player_o, self.grid)
        if self.grid.is_empty(row, col):
            self.grid.fill(
                player=self.current_player,
                row=row,
                col=col
            )
        else: raise BadCellError(self.current_player, row, col)
        self.current_player = self.get_switched_player()

    def get_winner(self):
        return self.grid.get_winner()

    def is_won(self):
        return True if self.grid.get_winner() is not None else False
Ejemplo n.º 4
0
    def test_neighbours002(self):
        g = Grid(4, 3)
        cell_00 = g.get_cell(0, 0)
        n = cell_00.neighbours(g)

        self.assertCountEqual([n.pos for n in cell_00.neighbours_cells(g)],
                              [(1, 0), (0, 1)])
Ejemplo n.º 5
0
 def test_move32_blank(self):
     g = Grid(4, 3)
     cell_32 = g.get_cell(3, 2)
     c = Cellgame()
     print(g)
     print(cell_32.neighbours(g))
     c.move(cell_32, g)
     print(g)
     self.assertCountEqual(
         [1, 1, 1],
         [g.get_cell(r[0], r[1]).state for r in [(2, 2), (3, 2), (3, 1)]])
Ejemplo n.º 6
0
 def test_3_vertical_fill_on_last_col_is_a_winning_pattern(self):
     player = Player('test')
     grid = Grid()
     self.assertIsNone(grid.get_winner())
     self.draw_winning_pattern(player,
                               grid,
                               row=0,
                               col=1,
                               vertical=True,
                               horizontal=False)
     self.assertEqual(player, grid.get_winner())
Ejemplo n.º 7
0
 def test_right_left_diagonal_is_a_winning_pattern(self):
     player = Player('test')
     grid = Grid()
     self.assertIsNone(grid.get_winner())
     self.draw_winning_pattern(player,
                               grid,
                               row=0,
                               col=2,
                               vertical=True,
                               horizontal=True)
     self.assertEqual(player, grid.get_winner())
Ejemplo n.º 8
0
 def test_move00_blank(self):
     g = Grid(4, 3)
     cell_00 = g.get_cell(0, 0)
     c = Cellgame()
     print(g)
     print(cell_00.neighbours(g))
     c.move(cell_00, g)
     print(g)
     print(repr(g))
     self.assertCountEqual(
         [1, 1, 1],
         [g.get_cell(r[0], r[1]).state for r in [(0, 0), (0, 1), (1, 0)]])
Ejemplo n.º 9
0
 def test_move32(self):
     g = Grid(4, 3)
     cell_21 = g.get_cell(3, 2)
     cell_21.state = 1
     c = Cellgame()
     print(g)
     print(cell_21.neighbours(g))
     c.move(cell_21, g)
     print(repr(g))
     print(g)
     self.assertCountEqual(
         [1, 1], [g.get_cell(r[0], r[1]).state for r in [(2, 2), (3, 1)]])
Ejemplo n.º 10
0
 def test_move23_blank_square(self):
     g = Grid(4, 4)
     cell_23 = g.get_cell(2, 3)
     c = Cellgame()
     print(g)
     print(cell_23.neighbours(g))
     c.move(cell_23, g)
     print(g)
     self.assertCountEqual([1, 1, 1, 1], [
         g.get_cell(r[0], r[1]).state
         for r in [(1, 3), (2, 2), (3, 3), (2, 3)]
     ])
Ejemplo n.º 11
0
    def test_move01(self):
        g = Grid(4, 3)
        c = Cellgame()
        cell_01 = g.get_cell(0, 1)
        cell_01.state = 1
        print(g)
        print(cell_01.neighbours_cells(g))
        c.move(cell_01, g)
        print(g)

        self.assertCountEqual(
            [1, 1, 1],
            [g.get_cell(r[0], r[1]).state for r in [(0, 2), (0, 0), (1, 1)]])
Ejemplo n.º 12
0
 def test_player_interface_can_ask_for_player_to_fill_a_cell(self):
     pi = PlayersInterface()
     x = Player('test')
     o = Player('test')
     g = Grid()
     with self.assertRaises(NotImplementedError):
         pi.choose_cell(x, x, o, g)
Ejemplo n.º 13
0
 def test_player_interface_can_display_winner(self):
     pi = PlayersInterface()
     x = Player('test')
     o = Player('test')
     g = Grid()
     with self.assertRaises(NotImplementedError):
         pi.display_winner(x, x, o, g)
Ejemplo n.º 14
0
 def test_that_a_grid_contain_the_right_cell_matrix(self):
     grid = Grid()
     self.assertEqual(3, len(grid.cells))
     self.assertEqual(3, len(grid.cells[0]))
     self.assertEqual(3, len(grid.cells[1]))
     self.assertEqual(3, len(grid.cells[2]))
     self.assertTrue(grid.cells[0][0].is_empty())
     self.assertTrue(grid.cells[2][2].is_empty())
Ejemplo n.º 15
0
class Game:
    def __init__(self, height, width):
        self.height = height
        self.width = width
        self.status = "running"
        self.grid = Grid(height, width)
        self.rules = Cellgame()

    def event_grid(self, x, y):
        self.rules.move(self.grid.get_cell(x, y), self.grid)
Ejemplo n.º 16
0
class TestGrid(unittest.TestCase):
    def setUp(self):
        self.grid = Grid(1, 1)

    def test_grid_to_string(self):
        self.assertEqual(str(self.grid), """[["{\'neighbors\': \'[]\'}"]]""")

    def test_grid_to_json(self):
        self.assertEqual(self.grid._json_repr(), {
            "width": 1,
            "height": 1,
            "cells": [
                [
                    {
                        "neighbors": [],
                        "filled": False
                    }
                ]
            ]
        })
Ejemplo n.º 17
0
 def __init__(self, height, width):
     self.height = height
     self.width = width
     self.status = "running"
     self.grid = Grid(height, width)
     self.rules = Cellgame()
Ejemplo n.º 18
0
def main():
    win = pygame.display.set_mode((540, 600))
    pygame.display.set_caption("Sudoku")
    board = Grid(9, 9, 540, 540, win)
    key = None
    run = True
    start = time.time()
    strikes = 0
    while run:

        play_time = round(time.time() - start)

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                run = False
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_1:
                    key = 1
                if event.key == pygame.K_2:
                    key = 2
                if event.key == pygame.K_3:
                    key = 3
                if event.key == pygame.K_4:
                    key = 4
                if event.key == pygame.K_5:
                    key = 5
                if event.key == pygame.K_6:
                    key = 6
                if event.key == pygame.K_7:
                    key = 7
                if event.key == pygame.K_8:
                    key = 8
                if event.key == pygame.K_9:
                    key = 9
                if event.key == pygame.K_DELETE:
                    board.clear()
                    key = None

                if event.key == pygame.K_SPACE:
                    board.solve_gui()

                if event.key == pygame.K_RETURN:
                    i, j = board.selected
                    if board.boxes[i][j].temp != 0:
                        if board.place(board.boxes[i][j].temp):
                            print("Success")
                        else:
                            print("Wrong")
                            strikes += 1
                        key = None

                        if board.is_finished():
                            print("Game over")

            if event.type == pygame.MOUSEBUTTONDOWN:
                pos = pygame.mouse.get_pos()
                clicked = board.click(pos)
                if clicked:
                    board.select(clicked[0], clicked[1])
                    key = None

        if board.selected and key != None:
            board.sketch(key)

        redraw_window(win, board, play_time, strikes)
        pygame.display.update()
Ejemplo n.º 19
0
 def test_cells_can_be_filled(self):
     grid = Grid()
     player = Player('test')
     grid.fill(player, 1, 1)
     self.assertFalse(grid.is_empty())
     self.assertEqual(player, grid.cells[1][1].player)
Ejemplo n.º 20
0
 def test_is_empty_return_grids_emptiness(self):
     grid = Grid()
     self.assertTrue(grid.is_empty())
Ejemplo n.º 21
0
 def test_neighbours12(self):
     g = Grid(4, 3)
     cell_12 = g.get_cell(1, 2)
     print(cell_12.neighbours(g))
     self.assertCountEqual(cell_12.neighbours(g), [(0, 2), (2, 2), (1, 1)])
Ejemplo n.º 22
0
 def test_is_empty_can_take_args_for_cell_emptiness(self):
     player = Player('test')
     grid = Grid()
     grid.fill(player, 0, 2)
     self.assertTrue(grid.is_empty(0, 1))
     self.assertFalse(grid.is_empty(0, 2))
Ejemplo n.º 23
0
 def setUp(self):
     self.grid = Grid()
     self.mr = MarsRover(self.grid)
Ejemplo n.º 24
0
 def setUp(self):
     self.grid = Grid(1, 1)
Ejemplo n.º 25
0
 def test_init(self):
     c = Cell(0, (1, 1), Grid(4, 3))
     self.assertEqual(c.pos, (1, 1))
Ejemplo n.º 26
0
 def test_grid_can_exist(self):
     grid = Grid()
     self.assertIsNotNone(grid)
Ejemplo n.º 27
0
    def test_import_level(self):
        g = Grid(4, 3)
        level_dict = g.serialize_level()

        level = g.import_level(level_dict)
        print(g)
Ejemplo n.º 28
0
 def test_neighbours00(self):
     g = Grid(4, 3)
     cell_00 = g.get_cell(0, 0)
     print(cell_00.neighbours(g))
     self.assertCountEqual(cell_00.neighbours(g), [(1, 0), (0, 1)])
Ejemplo n.º 29
0
 def test_init(self):
     g = Grid(4, 3)
     cell_12 = g.get_cell(1, 2)
     print(cell_12.pos)
     print(g)
     self.assertEqual(cell_12.pos, (1, 2))
Ejemplo n.º 30
0
class MarsRoverTester(unittest.TestCase):
    def setUp(self):
        self.grid = Grid()
        self.mr = MarsRover(self.grid)

    def test_initial_position(self):
        self.assertEqual(self.mr.getPosition(), (0,0))

    def test_initial_orientation(self):
        self.assertEqual(self.mr.getOrientation(), "N")

    def test_face_N(self):
        self.assertEqual(self.mr.getOrientation(), "N")

    def test_face_E(self):
        self.mr.turnRight()
        self.assertEqual(self.mr.getOrientation(), "E")

    def test_face_W(self):
        self.mr.turnLeft()
        self.assertEqual(self.mr.getOrientation(), "W")

    def test_face_S_turning_left(self):
        self.mr.turnLeft()
        self.mr.turnLeft()
        self.assertEqual(self.mr.getOrientation(), "S")

    def test_face_S_turning_right(self):
        self.mr.turnRight()
        self.mr.turnRight()
        self.assertEqual(self.mr.getOrientation(), "S")

    def test_face_N_turning_left(self):
        self.mr.turnLeft()
        self.mr.turnLeft()
        self.mr.turnLeft()
        self.mr.turnLeft()
        self.assertEqual(self.mr.getOrientation(), "N")

    def test_face_N_turning_right(self):
        self.mr.turnRight()
        self.mr.turnRight()
        self.mr.turnRight()
        self.mr.turnRight()
        self.assertEqual(self.mr.getOrientation(), "N")

    def test_move_F(self):
        self.mr.moveF()
        self.assertEqual(self.mr.getPosition(), (0,1))

    def test_size_of_grid(self):
        self.assertEqual(self.grid.getSize(), (100,100))

    def test_wrap_the_grid_N(self):
        initial_position = self.mr.getPosition()
        for i in range(initial_position[1], self.mr.getGrid().getSize()[1]):
            self.mr.moveF()
        self.assertEquals(self.mr.getPosition(), initial_position)

    def test_sequence_FFRFF(self):
        self.mr.moveF()
        self.mr.moveF()
        self.mr.turnRight()
        self.mr.moveF()
        self.mr.moveF()
        self.assertEqual(self.mr.getPosition(), (2, 2))
        self.assertEqual(self.mr.getOrientation(), "E")


    def tearDown(self):
        pass