1import math
  2
  3
  4def validate_uranium(func):
  5    def wrapper(self, mass, uranium):
  6        if uranium < 0 or uranium > 1:
  7            raise ValueError("Candy object's uranium value must be between 0 and 1 .")
  8        return func(self, mass, uranium)
  9
 10    return wrapper
 11
 12
 13class Candy:
 14    @validate_uranium
 15    def __init__(self, mass, uranium=0):
 16        self.__mass = mass
 17        self.__uranium = uranium
 18
 19    def get_uranium_quantity(self):
 20        return self.__mass * self.__uranium
 21
 22    def get_mass(self):
 23        return self.__mass
 24
 25
 26def validate_possition(func):
 27    def wrapper(self, possition):
 28        if type(possition) is not tuple:
 29            raise TypeError(
 30                "Person object's attribute possition must be of type tuple."
 31            )
 32        elif len(possition) != 2:
 33            raise ValueError(
 34                "Person object's attribute possition must contain two coordinates."
 35            )
 36        return func(self, possition)
 37
 38    return wrapper
 39
 40
 41class Person:
 42    @validate_possition
 43    def __init__(self, possition):
 44        self.__possition = possition
 45
 46    @validate_possition
 47    def set_possition(self, possition):
 48        self.__possition = possition
 49
 50    def get_possition(self):
 51        return self.__possition
 52
 53
 54def validate_candy(func):
 55    def wrapper(self, candy):
 56        if type(candy) is not Candy:
 57            raise TypeError("Kid object can have only Candy objects in its bag.")
 58        return func(self, candy)
 59
 60    return wrapper
 61
 62
 63def check_if_it_is_critital(func):
 64    def wrapper(self):
 65        total_uranium = 0
 66        for candy in self._Kid__bag:
 67            total_uranium += candy.get_uranium_quantity()
 68        if total_uranium > 20:
 69            return func(self, True)
 70        else:
 71            return func(self, False)
 72
 73    return wrapper
 74
 75
 76class Kid(Person):
 77    def __init__(self, possition, initiative):
 78        super().__init__(possition)
 79        self.__bag = set()
 80        self.__initiative = initiative
 81
 82    def get_initiative(self):
 83        return self.__initiative
 84
 85    @validate_candy
 86    def add_candy(self, candy):
 87        self.__bag.add(candy)
 88
 89    @check_if_it_is_critital
 90    def is_critical(self, Dead=False):
 91        return Dead
 92
 93
 94def validate_host_init(func):
 95    def wrapper(self, possition, candy_bag):
 96        valid_candy_bag = set()
 97        for candy in candy_bag:
 98            if len(candy) == 2:
 99                valid_candy_bag.add(Candy(*candy))
100            else:
101                raise ValueError(
102                    "Host object attribute candy_bag must contains candies with two attributes."
103                )
104        return func(self, possition, valid_candy_bag)
105
106    return wrapper
107
108
109def biggest_candy(candies):
110    best_candy = max(candies, key=lambda candy: candy.get_mass())
111    return best_candy
112
113
114class Host(Person):
115    @validate_host_init
116    def __init__(self, possition, candy_bag):
117        super().__init__(possition)
118        self.__candy_bag = candy_bag
119
120    def have_candies(self):
121        return bool(self.__candy_bag)
122
123    def remove_candy(self, func):
124        if self.__candy_bag:
125            element_to_remove = func(self.__candy_bag)
126            self.__candy_bag.remove(element_to_remove)
127            return element_to_remove
128        else:
129            return None
130
131
132def calculate_distance(point1, point2):
133    x1, y1 = point1
134    x2, y2 = point2
135    return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
136
137
138def closest_neighbour(func):
139    def wrapper(self, kid):
140        closest_host = min(
141            (
142                host
143                for host in self.hosts_kids_on_the_door
144                if host not in self.kids_visited[kid]
145            ),
146            key=lambda host: (
147                calculate_distance(host.get_possition(), kid.get_possition()),
148                host.get_possition()[0],
149                host.get_possition()[1],
150            ),
151        )
152        return func(self, kid, closest_host)
153
154    return wrapper
155
156
157def when_should_stop(func):
158    def wrapper(self):
159        if self.hosts_not_out_of_candies() and self.still_unvisited_hosts():
160            return func(self, False)
161        return func(self, True)
162
163    return wrapper
164
165
166class FluxCapacitor:
167    def __init__(self, participants):
168        self.participants = participants
169        self.__init_participarts(participants)
170
171    def __init_participarts(self, participants):
172        self.kids_visited = {}
173        self.hosts_kids_on_the_door = {}
174        self.__victims = set()
175        for participant in participants:
176            if isinstance(participant, Kid):
177                self.kids_visited[participant] = set()
178            elif isinstance(participant, Host):
179                self.hosts_kids_on_the_door[participant] = set()
180
181    # we are happy if even one host have candies left,
182    # so the game makes sence to continue
183    def hosts_not_out_of_candies(self):
184        for host in self.hosts_kids_on_the_door:
185            if host.have_candies():
186                return True
187        return False
188
189    def still_unvisited_hosts(self):
190        hosts_count = len(self.hosts_kids_on_the_door)
191        for kid, visited_hosts in self.kids_visited.items():
192            if len(visited_hosts) < hosts_count:
193                return True
194        return False
195
196    @when_should_stop
197    def __should_stop(self, stop=False):
198        return stop
199
200    def __go_to_host(self, kid, host):
201        self.hosts_kids_on_the_door[host].add(kid)
202        self.kids_visited[kid].add(host)
203        kid.set_possition(host.get_possition())
204
205    @closest_neighbour
206    def __find_host(self, kid, closest_host=None):
207        return closest_host
208
209    def __hosts_give_candies(self):
210        for host, kids_on_the_door in self.hosts_kids_on_the_door.items():
211            if kids_on_the_door:
212                sorted_kids = sorted(
213                    kids_on_the_door, key=lambda kid: kid.get_initiative(), reverse=True
214                )
215                for kid in sorted_kids:
216                    candy = host.remove_candy(biggest_candy)
217                    if candy:
218                        kid.add_candy(candy)
219                    self.hosts_kids_on_the_door[host].discard(
220                        kid
221                    )  # Remove the kid from the set
222
223    def __add_victim(self, kid):
224        self.__victims.add(kid)
225
226    def __have_victims(self):
227        if self.__victims:
228            return True
229        return False
230
231    def __collect_victims(self):
232        for kid in self.kids_visited.keys():
233            if kid.is_critical():
234                self.__add_victim(kid)
235
236    def get_victim(self):
237        while not self.__should_stop():
238            for kid in self.kids_visited:
239                host_to_go = self.__find_host(kid)
240                if host_to_go:
241                    self.__go_to_host(kid, host_to_go)
242            self.__hosts_give_candies()
243            self.__collect_victims()
244            if self.__have_victims():
245                return self.__victims
246        return None
247
248
249kid1 = Kid((0, 0), 5)
250kid2 = Kid((1, 1), 3)
251host1 = Host(
252    (2, 2),
253    [
254        (10, 0.2),
255    ],
256)
257host2 = Host((3, 3), [])
258host3 = Host((4, 4), [(100, 0.1), (99, 0.5)])
259host4 = Host(
260    (5, 5),
261    [(3, 0.4)],
262)
263
264flux = FluxCapacitor({kid1, kid2, host1, host2, host3, host4})
265
266# Run the simulation
267victims = flux.get_victim()
268print("Victims:", victims)