tetris/tetromino_test.py at master · bartq98/tetris · GitHub

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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#!/bin/python3.8

"""
    Tests of class Tetromino from module tetromino
"""

import unittest

import config
import tetromino
import gameboard


class TetrominoTest(unittest.TestCase):

    def test__init__(self):
        testing_x = 3
        testing_y = 4
        testing_times_rotated = 1
        testing_type = "T"

        tetromino_proper_shape = [
            [0, 0, 0, 0],
            [0, 1, 0, 0],
            [0, 1, 1, 0],
            [0, 1, 0, 0],
        ]

        testing_tetromino = tetromino.Tetromino(type=testing_type, times_rotated=testing_times_rotated, x=testing_x, y=testing_y)
        self.assertEqual(testing_tetromino.current_x, testing_x)
        self.assertEqual(testing_tetromino.current_y, testing_y)
        self.assertEqual(testing_tetromino.buffer, tetromino_proper_shape)

    def test_rotate(self):
        """Testing method rotate from Tetromino."""

        # test for config.TETROMINO_SHAPES["I"] rotated once clockwise and oposite
        testing_tetromino = tetromino.Tetromino("I")
        testing_tetromino.buffer = testing_tetromino.rotate(testing_tetromino.buffer)
        I_after_rotate = [
            [0, 0, 0, 0],
            [0, 0, 0, 0],
            [1, 1, 1, 1],
            [0, 0, 0, 0],
        ]
        self.assertEqual(testing_tetromino.buffer, I_after_rotate)
        testing_tetromino.buffer = testing_tetromino.rotate(testing_tetromino.buffer, clockwise=False) # return to previous (initial) value
        self.assertEqual(testing_tetromino.buffer, config.TETROMINO_SHAPES["I"])

        # test for config.TETROMINO_SHAPES["Z"] rotated once clockwise and oposite
        testing_tetromino = tetromino.Tetromino("Z")

        testing_tetromino.buffer = testing_tetromino.rotate(testing_tetromino.buffer)
        Z_after_rotate = [
            [0, 0, 0, 0],
            [0, 0, 1, 0],
            [0, 1, 1, 0],
            [0, 1, 0, 0],
        ]
        self.assertEqual(testing_tetromino.buffer, Z_after_rotate)

        testing_tetromino.buffer = testing_tetromino.rotate(testing_tetromino.buffer)
        testing_tetromino.buffer = testing_tetromino.rotate(testing_tetromino.buffer, clockwise=False)
        # should be same like previous - Z_after_rotate
        self.assertEqual(testing_tetromino.buffer, Z_after_rotate)

        testing_tetromino.buffer = testing_tetromino.rotate(testing_tetromino.buffer)
        Z_after_rotate_once_again = [
            [0, 0, 0, 0],
            [1, 1, 0, 0],
            [0, 1, 1, 0],
            [0, 0, 0, 0],
        ]
        self.assertEqual(testing_tetromino.buffer, Z_after_rotate_once_again)

    def test_fall_down(self):
        gameboard_tested = gameboard.Gameboard()
        testing_tetromino = tetromino.Tetromino("I", times_rotated=0, x=3, y=18)
        self.assertEqual(testing_tetromino.fall_down(gameboard_tested), True)

        # simulating falling of three blocks down
        testing_tetromino.current_y -= 3
        self.assertEqual(testing_tetromino.fall_down(gameboard_tested), False)
        testing_tetromino.current_y += 3
        self.assertEqual(testing_tetromino.fall_down(gameboard_tested), True)

    def test_will_collide(self):
        gameboard_tested = gameboard.Gameboard()
        # filling some of blocks [row][column]
        gameboard_tested.fields[4][6] = config.FALLEN_BLOCK
        gameboard_tested.fields[4][7] = config.FALLEN_BLOCK
        gameboard_tested.fields[4][8] = config.FALLEN_BLOCK
        testing_tetromino = tetromino.Tetromino("I", times_rotated=0, x=5, y=0)
        self.assertEqual(testing_tetromino.will_collide(gameboard_tested), False)
        # should intersects while fall one block down
        testing_tetromino.current_y += 2
        self.assertEqual(testing_tetromino.will_collide(gameboard_tested), True)

    def test_calculate_buffor_drawing_coordinates(self):
        testing_tetromino = tetromino.Tetromino("I", times_rotated=0, x=5, y=0)
        x_to_test = testing_tetromino.current_x
        y_to_test = testing_tetromino.current_y

        x_to_draw_rect = (x_to_test * config.BLOCK_SIZE) + config.GAME_BOARD_COORDS.left
        y_to_draw_rect = (y_to_test * config.BLOCK_SIZE) + config.GAME_BOARD_COORDS.top

        self.assertEqual(testing_tetromino.calculate_buffor_drawing_coordinates(), (x_to_draw_rect, y_to_draw_rect))


if __name__ == "__main__":
    unittest.main()