1import math
  2import copy
  3
  4def once(func):
  5    def wrapper(target):
  6        if wrapper.called:
  7            raise TypeError("Effect is depleted.")
  8        wrapper.called = True
  9        func(target)
 10    wrapper.called = False
 11    return wrapper
 12
 13def calling_function_decorator(function, times):
 14    @once
 15    def decorator(target):
 16        for _ in range(times):
 17            function(target)
 18    return decorator
 19
 20class Potion:
 21
 22    def __hash__(self):
 23        hash_value = 0
 24        for effect_name, intensity in self.intensity.items():
 25            hash_value ^= hash((effect_name, intensity))
 26        return hash_value
 27
 28    def round_intensity(self,to_return,effect_name):
 29         to_return.intensity[effect_name] = math.floor(to_return.intensity[effect_name]) if  to_return.intensity[effect_name] <= int(to_return.intensity[effect_name]) +0.5 else math.ceil(to_return.intensity[effect_name])
 30
 31    def is_depleted(self):
 32         is_depleted_var = True
 33         for effect_name,effect in self.effects.items():
 34            function = getattr(self, effect_name)
 35            try:
 36                function(None)               
 37            except TypeError:
 38                is_depleted_var = True
 39                continue
 40            finally:
 41                setattr(self, effect_name, calling_function_decorator(effect, self.intensity[effect_name]))
 42                return False
 43         return is_depleted_var
 44    
 45    @staticmethod
 46    def already_used(target):
 47        raise TypeError("Potion is now part of something bigger than itself.")
 48    
 49    def __init__(self,effects, duration):
 50        self.effects = copy.copy(effects)
 51        self.was_used = False
 52        self.intensity = {}
 53        for effect_name in self.effects:
 54            self.intensity[effect_name] = 1
 55        for effect_name,effect in effects.items():
 56             setattr(self, effect_name, calling_function_decorator(effect, self.intensity[effect_name]))
 57             self.effects[effect_name] = effect
 58        self.duration = duration
 59
 60    def __add__(self, other):
 61        if self.is_depleted() or other.is_depleted():
 62            raise TypeError("Potion is depleted.")
 63        if self.was_used == True or other.was_used == True:
 64            raise TypeError("Potion is now part of something bigger than itself.")
 65        to_return = Potion(self.effects, max(self.duration, other.duration)) 
 66        for effect_name,effect in to_return.effects.items():
 67            to_return.intensity[effect_name]=self.intensity[effect_name]
 68            setattr(to_return, effect_name, calling_function_decorator(effect, to_return.intensity[effect_name]))
 69        for effect_name,effect in other.effects.items():
 70            if effect_name in to_return.effects:
 71                to_return.intensity[effect_name] += 1       
 72                setattr(to_return, effect_name, calling_function_decorator(effect, to_return.intensity[effect_name]))
 73            else:
 74                to_return.intensity[effect_name] = other.intensity[effect_name]   
 75                setattr(to_return, effect_name, calling_function_decorator(effect, to_return.intensity[effect_name]))
 76                to_return.effects[effect_name] = effect
 77        for effect_name in self.effects:
 78            setattr(self, effect_name, self.already_used)
 79        for effect_name in other.effects:
 80            setattr(other, effect_name, other.already_used)
 81        self.was_used = other.was_used = True
 82        return to_return
 83    
 84    def __mul__(self, value):
 85        if self.is_depleted():
 86            raise TypeError("Potion is depleted.")
 87        if self.was_used == True:
 88            raise TypeError("Potion is now part of something bigger than itself.")
 89        if value >= 0 and value <= 1:
 90            to_return = Potion(self.effects, self.duration)
 91            for effect_name in to_return.effects:
 92                to_return.intensity[effect_name] = self.intensity[effect_name]
 93            for effect_name,effect in to_return.effects.items():
 94                to_return.intensity[effect_name] *= value
 95                self.round_intensity(to_return,effect_name)
 96                setattr(to_return, effect_name, calling_function_decorator(effect, to_return.intensity[effect_name]))
 97               #  to_return.intensity[effect_name] = math.floor(to_return.intensity[effect_name]) if  to_return.intensity[effect_name] <= 0.5 else math.ceil(to_return.intensity[effect_name])              
 98            for effect_name in self.effects:
 99                setattr(self, effect_name, self.already_used)
100            self.was_used = True
101            return to_return
102        to_return = Potion(self.effects, self.duration)
103        for effect_name in to_return.effects:
104            to_return.intensity[effect_name] = self.intensity[effect_name]
105        for effect_name in to_return.effects:
106            to_return.intensity[effect_name] *= value
107        for effect_name,effect in to_return.effects.items():
108             setattr(to_return, effect_name, calling_function_decorator(effect, to_return.intensity[effect_name]))
109        for effect_name in self.effects:
110            setattr(self, effect_name, self.already_used)
111        self.was_used = True
112        return to_return
113    
114    def __sub__(self, other):
115        if self.is_depleted() or other.is_depleted():
116            raise TypeError("Potion is depleted.")
117        if self.was_used == True or other.was_used == True:
118            raise TypeError("Potion is now part of something bigger than itself.")
119        to_return = Potion(self.effects, self.duration)
120        for effect_name,effect in to_return.effects.items():
121            to_return.intensity[effect_name] = self.intensity[effect_name]
122            setattr(to_return, effect_name, calling_function_decorator(effect,to_return.intensity[effect_name]))
123        for effect_name in other.effects:
124            if effect_name not in to_return.effects:
125                raise TypeError("Error")
126        for effect_name, effect in other.effects.items():
127            if to_return.intensity[effect_name] > other.intensity[effect_name]:
128                to_return.intensity[effect_name] -= other.intensity[effect_name]
129                setattr(to_return, effect_name, calling_function_decorator(effect, to_return.intensity[effect_name]))
130            else:
131                delattr(to_return, effect_name)
132                del to_return.effects[effect_name]
133                del to_return.intensity[effect_name]
134        for effect_name in self.effects:
135            setattr(self, effect_name, self.already_used)
136        for effect_name in other.effects:
137            setattr(other, effect_name, other.already_used)
138        self.was_used = other.was_used = True
139        return to_return
140
141    def __truediv__(self, value):
142        if self.is_depleted():
143            raise TypeError("Potion is depleted.")
144        if self.was_used == True:
145            raise TypeError("Potion is now part of something bigger than itself.")
146        copy_potion=Potion(self.effects,self.duration)
147        for effect_name in self.intensity:
148            copy_potion.intensity[effect_name] = self.intensity[effect_name]
149        for effect_name,effect in copy_potion.effects.items():
150            copy_potion.intensity[effect_name] /= value
151            self.round_intensity(copy_potion,effect_name)
152            #copy.intensity[effect_name] = math.floor(copy.intensity[effect_name]) if  copy.intensity[effect_name] <= 0.5 else math.ceil(copy.intensity[effect_name])
153            setattr(copy_potion,effect_name, calling_function_decorator(effect, copy_potion.intensity[effect_name]))        
154        potion_list=[]
155        for _ in range(value):
156            copy=Potion(copy_potion.effects,copy_potion.duration)
157            for effect_name in copy_potion.intensity:
158                copy.intensity[effect_name] = copy_potion.intensity[effect_name]
159            for effect_name,effect in copy_potion.effects.items():
160                setattr(copy,effect_name, calling_function_decorator(effect, copy_potion.intensity[effect_name]))
161            potion_list.append(copy)
162        for effect_name in self.effects:
163            setattr(self, effect_name, self.already_used)
164        self.was_used = True
165        return tuple(potion_list)
166 
167    def __eq__(self,other):
168        if self.is_depleted() or other.is_depleted():
169            raise TypeError("Potion is depleted.")
170        if self.was_used == True or other.was_used == True:
171            raise TypeError("Potion is now part of something bigger than itself.")
172        for effect_name in self.effects:
173            if effect_name not in other.effects:
174                return False
175        for effect_name in self.effects:
176            if self.intensity[effect_name] != other.intensity[effect_name]:
177                return False
178        return True
179    
180    def __gt__(self,other):
181        if self.is_depleted() or other.is_depleted():
182            raise TypeError("Potion is depleted.")
183        if self.was_used == True or other.was_used == True:
184            raise TypeError("Potion is now part of something bigger than itself.")
185        sum_of_self = 0
186        for effect_name in self.intensity:
187            sum_of_self+=self.intensity[effect_name]
188        sum_of_other = 0
189        for effect_name in other.intensity:
190            sum_of_other += other.intensity[effect_name]
191        return sum_of_self > sum_of_other
192        
193
194def sorting_potions(potion):
195        name = potion[0]
196        sum_of_potion_name = 0
197        for letter in name:
198            sum_of_potion_name += ord(letter)
199        return sum_of_potion_name
200
201
202class ГоспожатаПоХимия:
203    def __init__(self):
204        self.used_potions = []
205        self.targets_copies = {}
206        self.targets_buffed_copies = {}
207
208    def apply(self, target, potion):
209        if potion.duration == 0:
210            return
211        if potion.is_depleted():
212            raise TypeError("Potion is depleted.")
213        if potion.was_used:
214            raise TypeError("Potion is now part of something bigger than itself.")
215        sorted_potions = sorted(potion.effects.items(), key=sorting_potions, reverse=True)
216        potion.effects = dict(sorted_potions)
217        if target not in self.targets_buffed_copies.values():
218            self.targets_copies[potion] = copy.copy(target)
219        else:
220            for potion_loop in self.used_potions:
221                potion_loop.was_used = False
222                if self.targets_buffed_copies[potion_loop] == target:
223                    self.targets_copies[potion] = copy.copy(self.targets_copies[potion_loop])
224                potion_loop.was_used = True
225        self.used_potions.append(potion)
226        for effect_name in potion.effects:
227            function = getattr(potion, effect_name)
228            try:
229                function(target)
230            except TypeError:
231                continue
232        for potion_iter in self.used_potions:
233            potion_iter.was_used = False
234        self.targets_buffed_copies[potion] = target
235        potion.was_used = True
236        for potion_iter in self.used_potions:
237            potion_iter.was_used = True
238    
239    def tick(self):
240        for potion in self.used_potions:
241            potion.duration -= 1
242            if potion.duration == 0:
243                self.targets_buffed_copies[potion].__dict__ = vars(self.targets_copies[potion])
244                for potion_inner in self.used_potions:
245                    potion_inner.was_used = False
246                    potion.was_used = False
247                    if potion_inner == potion or potion_inner.duration <= 0 or self.targets_buffed_copies[potion] != self.targets_buffed_copies[potion_inner]:
248                        potion_inner.was_used = True
249                        potion.was_used = True
250                        continue
251                    potion_inner.was_used = True
252                    potion.was_used = True
253                    copy = Potion(potion_inner.effects,potion_inner.duration)
254                    for effect_name,effect in  copy.effects.items():
255                         copy.intensity[effect_name] = potion_inner.intensity[effect_name]
256                         setattr(copy, effect_name, calling_function_decorator(effect, copy.intensity[effect_name]))
257                    for effect_name in  copy.effects:
258                        function = getattr(copy, effect_name)
259                        function(self.targets_buffed_copies[potion])