python-bfs/RectangleGroup.py at master · marcelodelazari/python-bfs · 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
import random
import time
from Rectangle import Rectangle


class RectangleGroup(object):

    def __init__(self, grid, group_id, center, target):
        self.rectangles_positions = set()
        self.rectangles = []

        self.grid = grid
        self.group_id = group_id
        self.center = center
        self.COLOR = (random.randrange(10, 230), random.randrange(50, 200), random.randrange(50, 200))

        self.first_rectangle = Rectangle(None, center[0], center[1], self.group_id, self.COLOR, True)
        self.rectangles.append(self.first_rectangle)
        self.rectangles_positions.add((center[0], center[1]))

        self.target = target
        self.growing = True
        self.found_path = False
        self.t = None

    def restart(self):
        self.rectangles_positions.clear()
        self.rectangles.clear()

    def add_target(self, pos):
        self.target = pos

    def grow_rectangle(self, rectangle):
        if self.t is None:
            self.t = time.time()

        growth = False
        if rectangle.is_growing:
            rectangle.is_growing = False

            x = rectangle.x
            y = rectangle.y

            up = (x, y - 1)
            down = (x, y + 1)
            right = (x + 1, y)
            left = (x - 1, y)

            for pos in [up, down, right, left]:
                if self.grid.is_inside(pos) and not self.grid.is_obstacle(pos) and pos not in self.rectangles_positions:
                    new_rectangle = Rectangle(rectangle, pos[0], pos[1], self.group_id, self.COLOR, False)
                    self.rectangles_positions.add(pos)
                    self.rectangles.append(new_rectangle)
                    growth = True

                    if pos == self.target:
                        self.growing = False
                        right_path = self.path(new_rectangle)
                        self.found_path = True
                        return self.found_path, right_path, growth

        return self.found_path, False, growth

    #  deletes all rectangles that doesnt belong to the right path
    def path(self, rectangle):
        path_rectangles = []

        while rectangle is not None:
            path_rectangles.append(rectangle)
            rectangle = rectangle.father

        self.rectangles_positions.clear()
        self.rectangles.clear()

        for rectangle in path_rectangles:
            self.rectangles_positions.add(rectangle.get_pos())
            self.rectangles.append(rectangle)

        print("Distance:", len(self.rectangles_positions) - 1)
        return path_rectangles

    def grow_rectangles(self):
        if self.growing:
            growth_at_least_once = False
            for i in range(len(self.rectangles)):
                found_path, possible_path, growth = self.grow_rectangle(self.rectangles[i])
                if growth:
                    growth_at_least_once = True
                if found_path:
                    break

            if not growth_at_least_once:
                self.growing = False
                self.only_first()
        return False

    # deletes all except the first
    def only_first(self):
        self.rectangles_positions.clear()
        self.rectangles.clear()
        self.rectangles.append(self.first_rectangle)
        self.rectangles_positions.add(self.first_rectangle.get_pos())
        print("No path was found.")

    def pos_occupied(self, pos):
        return pos in self.rectangles_positions

    def get_score(self):
        if len(self.rectangles_positions) <= 1:
            return "N"
        return len(self.rectangles_positions) - 1