1import copy
  2import math
  3
  4class Effect:
  5    def __init__(self, name, func, intensity=1):
  6        self.name = name
  7        self.func = func
  8        self.is_used = False
  9        self.intensity = intensity
 10        self.is_active = True
 11
 12    @property
 13    def molecular_mass(self):
 14        return sum([ord(letter) for letter in self.name])
 15    
 16    def __call__(self, target, is_continuing=False):
 17        if not self.is_used or is_continuing:
 18            for _ in range(self.intensity):
 19                self.func(target)
 20            self.is_used = True
 21        else:
 22            raise TypeError("Effect is depleted.")
 23        
 24
 25class Potion:
 26    def __init__(self, effects, duration=2, intensities=None):
 27        self.effects = {}
 28        self.is_itself = True
 29        self.is_used = False
 30
 31        for effect_name in effects:
 32            effect_func = effects[effect_name]
 33            effects[effect_name].is_called = False
 34
 35            self.effects[effect_name] = Effect(effect_name, effect_func, 1 if intensities is None else intensities[effect_name])
 36
 37        self.duration = duration
 38
 39    def effect(self, target, is_continuing=False):
 40        if not is_continuing and not self.is_itself:
 41            raise TypeError("Potion is now part of something bigger than itself.")
 42        
 43        if self.is_used and not is_continuing:
 44            raise TypeError("Potion is depleted.")
 45        
 46        self.is_used = True
 47        self.effects = dict(sorted(self.effects.items(), key=lambda x: x[1].molecular_mass, reverse=True))
 48
 49        for effect in self.effects.values():
 50            if not effect.is_active:
 51                continue
 52            effect(target, True)
 53        
 54    def __getattr__(self, effect_name):
 55        if effect_name not in self.effects:
 56            raise AttributeError("Effect is not in potion.")
 57        
 58        if self.is_used:
 59            raise TypeError("Potion is depleted.")
 60        
 61        if not self.effects[effect_name].is_active:
 62            raise TypeError("Effect is depleted.")
 63        
 64        if not self.is_itself:
 65            raise TypeError("Potion is now part of something bigger than itself.")
 66        
 67        self.effects[effect_name].is_active = False
 68
 69        return self.effects[effect_name]
 70
 71    def __add__(self, other):
 72        """Combining two potions."""
 73        if not self.is_itself or not other.is_itself:
 74            raise TypeError("Potion is now part of something bigger than itself.")
 75        
 76        if self.is_used:
 77            raise TypeError("Potion is depleted.")
 78        
 79        effects = {}
 80        intensities = {}
 81
 82        for effect_name, effect in self.effects.items():
 83            if not effect.is_active:
 84                continue
 85            effects[effect_name] = effect.func
 86            intensities[effect_name] = effect.intensity
 87        
 88        for effect_name, effect in other.effects.items():
 89            if not effect.is_active:
 90                continue
 91
 92            if effect_name not in effects:
 93                effects[effect_name] = effect.func
 94                intensities[effect_name] = effect.intensity
 95            else:
 96                intensities[effect_name] += effect.intensity
 97    
 98        self.is_itself = False
 99        other.is_itself = False
100
101        return Potion(effects, max(self.duration, other.duration), intensities)
102    
103    def __mul__(self, number):
104        """Potentiation of two potions."""
105        if not self.is_itself:
106            raise TypeError("Potion is now part of something bigger than itself.")
107        
108        if self.is_used:
109            raise TypeError("Potion is depleted.")
110        
111        effects = {}
112        intensities = {}
113
114        for effect_name, effect in self.effects.items():
115            if not effect.is_active:
116                continue
117
118            intensities[effect_name] = effect.intensity * number
119
120            if intensities[effect_name] % 1 <= 0.5:
121                intensities[effect_name] = math.floor(intensities[effect_name])
122            else:
123                intensities[effect_name] = math.ceil(intensities[effect_name])
124
125            effects[effect_name] = effect.func
126
127        self.is_itself = False
128        return Potion(effects, self.duration, intensities)
129    
130    def __sub__(self, other):
131        """Purification of two potions."""
132        if not self.is_itself or not other.is_itself:
133            raise TypeError("Potion is now part of something bigger than itself.")
134        
135        if self.is_used:
136            raise TypeError("Potion is depleted.")
137        
138        for effect in other.effects:
139            if effect not in self.effects:
140                raise TypeError("Effect is not in potion.")
141        
142        effects = {}
143        intensities = {}
144
145        for effect_name, effect in self.effects.items():
146            intensities[effect_name] = effect.intensity
147            effects[effect_name] = effect.func
148
149            if not effect.is_active:
150                intensities[effect_name] = max(intensities[effect_name] - 1, 0)
151
152        for effect in other.effects:
153            intensities[effect] -= other.effects[effect].intensity
154
155            if not other.effects[effect].is_active and other.effects[effect].intensity > 0:
156                intensities[effect] += 1
157
158            if intensities[effect] <= 0:
159                effects.pop(effect)
160                intensities.pop(effect)
161
162        self.is_itself = False
163        other.is_itself = False
164        return Potion(effects, self.duration, intensities)
165    
166    def __truediv__(self, number:int):
167        """Dividing two potions."""
168        if not self.is_itself:
169            raise TypeError("Potion is now part of something bigger than itself.")
170        
171        if self.is_used:
172            raise TypeError("Potion is depleted.")
173        
174        effects = {}
175        intensities = {}
176
177        for effect_name, effect in self.effects.items():
178            if not effect.is_active:
179                continue
180
181            intensities[effect_name] = int(effect.intensity) / number
182            effects[effect_name] = effect.func
183
184            if intensities[effect_name] % 1 <= 0.5:
185                intensities[effect_name] = math.floor(intensities[effect_name])
186            else:
187                intensities[effect_name] = math.ceil(intensities[effect_name])
188        
189        self.is_itself = False
190        return tuple(Potion(effects, self.duration, intensities) for _ in range(number))
191    
192    def __eq__(self, other):
193
194        if not self.is_itself or not other.is_itself:
195            raise TypeError("Potion is now part of something bigger than itself.")
196        
197        if self.is_used:
198            raise TypeError("Potion is depleted.")
199        
200        for effect in self.effects:
201            if effect not in other.effects:
202                return False
203            
204            if not self.effects[effect].is_active:
205                self.effects[effect].intensity = 0
206
207            if not other.effects[effect].is_active:
208                other.effects[effect].intensity = 0
209
210            if self.effects[effect].intensity != other.effects[effect].intensity:
211                return False
212            
213        for effect in other.effects:
214            if effect not in self.effects or self.effects[effect].intensity != other.effects[effect].intensity:
215                return False
216            
217        return True
218
219    def __lt__(self, other):
220
221        if not self.is_itself or not other.is_itself:
222            raise TypeError("Potion is now part of something bigger than itself.")
223        
224        if self.is_used:
225            raise TypeError("Potion is depleted.")
226        
227        
228        return sum(effect.intensity if effect.is_active else 0 for effect in self.effects.values()) < sum(effect.intensity if effect.is_active else 0  for effect in other.effects.values())
229    
230    def __dir__(self):
231        return list(self.effects.keys())
232
233
234class Target:
235    def __init__(self, target):
236        self.curr_target = target
237        self.original = copy.deepcopy(target.__dict__)
238
239    @property
240    def original_state(self):
241        return copy.deepcopy(self.original)
242
243    def back_to_original(self):
244        self.curr_target.__dict__ = self.original_state
245
246    def __eq__(self, other):
247        if isinstance(other, Target):
248            return self.curr_target.__class__.__name__ == other.curr_target.__class__.__name__
249        return False
250
251    def __hash__(self):
252        return hash(self.curr_target.__class__.__name__)
253
254class ГоспожатаПоХимия:
255    def __init__(self):
256        self.active_potions = {}
257    
258    def apply(self, target_obj, potion):
259        target = Target(target_obj)
260        
261        if self.active_potions.get(target) is None:
262            self.active_potions[target] = []
263
264        if potion.duration > 0:
265            potion.effect(target.curr_target)
266            self.active_potions[target].append([potion.duration - 1, potion])
267    
268    def tick(self):
269        for target in self.active_potions:
270            target.back_to_original()
271            to_remove = []
272
273            for curr in self.active_potions[target]:
274                remaining_time, potion = curr
275                curr[0] -= 1
276
277                if remaining_time <= 0:
278                    to_remove.append(curr)
279                else:
280                    potion.effect(target.curr_target, True)
281
282            for curr in to_remove:
283                self.active_potions[target].remove(curr)