1import math
  2
  3
  4class Potion:
  5    def __init__(self, effects, duration):
  6        '''Тук effects_used съдържа имената на методите и интензитета на
  7        всеки метод. effects_applicable съдържа boolean стойности за всеки метод
  8        дали съответният метод е използваем. Накрая, used_in_reaction се използва,
  9        за да се следи дали поушънката е използвана в реакция(в това влиза да е 
 10        apply-вана) или не.'''
 11
 12        self.effects = dict(effects)
 13        self.duration = duration
 14        self._create_effect_methods()
 15        self.effects_used = {k: 1 for k in self.effects}
 16        self.effects_applicable = {k: True for k in self.effects}
 17        self.used_in_reaction = False
 18    
 19    def _create_effect_methods(self):
 20        for effect_name, effect_function in self.effects.items():
 21            setattr(self, effect_name, 
 22                    self._create_effect_wrapper(effect_name, effect_function))
 23
 24    def _create_effect_wrapper(self, effect_name, effect_func):
 25        def wrapper(target):
 26            if (all(value == False for value in 
 27                    self.effects_applicable.values())):
 28                raise TypeError('Potion is depleted')
 29            elif not self.effects_applicable[effect_name]:
 30                raise TypeError('Effect is depleted.')
 31            else:
 32                for intensity in range(self.effects_used[effect_name]):
 33                    effect_func(target)
 34                    self.effects_used[effect_name] -= 1 
 35                self.effects_applicable[effect_name] = False
 36        return wrapper
 37
 38    def __add__(self, other):
 39        if not ((all(value == False for value in self.effects_applicable.values()))
 40            or 
 41            (all(value == False for value in other.effects_applicable.values()))):
 42
 43            new_pot_effects = self.effects.copy()
 44            new_pot_effects_used = self.effects_used.copy()
 45            
 46            for effect_name, effect_function in other.effects.items():
 47                try:
 48                    new_pot_effects_used[effect_name] += other.effects_used[effect_name]
 49                except KeyError:
 50                    new_pot_effects[effect_name] = effect_function
 51                    new_pot_effects_used[effect_name] = other.effects_used[effect_name]
 52
 53            new_pot_durat = 0
 54            if self.duration >= other.duration:
 55                new_pot_durat = self.duration
 56            else:
 57                new_pot_durat = other.duration
 58            new_potion = Potion(new_pot_effects, new_pot_durat) 
 59            new_potion.effects_used = new_pot_effects_used
 60
 61            for k, v in self.effects.items():
 62                delattr(self, k)
 63            self.effects.clear()
 64            for k, v in other.effects.items():
 65                delattr(other, k)
 66            for k, v in self.effects_used.items():
 67                self.effects_used[k] = 0
 68            self.used_in_reaction = True
 69            other.used_in_reaction = True
 70
 71        else:
 72            raise TypeError('Potion is depleted.')
 73        return new_potion
 74
 75    def __mul__(self, num):
 76        if not all(value == False for value in self.effects_applicable.values()):
 77            new_potion = Potion(self.effects.copy(), self.duration)
 78            new_potion.effects_used = self.effects_used.copy()
 79            new_potion.effects_applicable = self.effects_applicable.copy()
 80            
 81            for k, v in new_potion.effects_used.items():
 82
 83                new_potion.effects_used[k] *= num
 84                shorter_length = new_potion.effects_used[k]
 85                if shorter_length <= math.floor(shorter_length) + 1.5:
 86                    new_potion.effects_used[k] = math.floor(shorter_length)
 87                else:
 88                    new_potion.effects_used[k] = math.ceil(shorter_length)
 89                
 90            for k, v in self.effects.items():
 91                delattr(self, k)
 92            for k, v in self.effects_used.items():
 93                self.effects_used[k] = 0
 94            self.used_in_reaction = True
 95            for k, v in self.effects_applicable.items():
 96                self.effects_applicable[k] = False
 97        else:
 98            raise TypeError('Potion is depleted.')
 99        
100
101        return new_potion
102    
103    def __sub__(self, other):
104        if not ((all(value == False for value in self.effects_applicable.values())) 
105            or 
106            (all(value == False for value in other.effects_applicable.values()))):
107
108            new_potion = Potion(self.effects.copy(), self.duration)
109            new_potion.effects_used = self.effects_used.copy()
110            
111            self.used_in_reaction = True
112            other.used_in_reaction = True
113
114            for k, v in other.effects.items():
115                if k not in self.effects:
116                    raise TypeError('ne izdyrjam poveche na tozi jivot')
117                else:
118                    intens = new_potion.effects_used[k] - other.effects_used[k]
119                    if intens <= 0:
120                        new_potion.effects.pop(k)
121                        delattr(new_potion, k)
122                        new_potion.effects_used.pop(k)
123                    else:
124                        new_potion.effects_used[k] -= intens
125
126            for k, v in self.effects.items():
127                delattr(self, k)
128            self.effects.clear()
129            for k, v in self.effects_used.items():
130                self.effects_used[k] = 0
131            
132            for k, v in other.effects.items():
133                delattr(other, k)
134            other.effects.clear()
135            other.effects_used.clear()
136        else:
137            raise TypeError('Potion is depleted.')
138
139        return new_potion
140    
141    def __truediv__(self, number):
142        if not all(value == False for value in self.effects_applicable.values()):
143            divided_potions = []
144
145            new_pot = Potion(self.effects.copy(), self.duration)
146            new_pot.effects_used = self.effects_used.copy()
147            self.used_in_reaction = True
148
149            for k, v in new_pot.effects_used.items():
150                new_pot.effects_used[k] /= number
151                shorter_length = new_pot.effects_used[k]
152                if shorter_length <= math.floor(shorter_length) + 0.5:
153                    new_pot.effects_used[k] = math.floor(shorter_length)
154                else:
155                    new_pot.effects_used[k] = math.ceil(shorter_length)
156            
157            for _ in range(number):
158                divided_potions.append(new_pot)
159            
160            for k, v in self.effects.items():
161                delattr(self, k)
162            self.effects.clear()
163            self.effects_used.clear()
164            for k, v in self.effects_applicable.items():
165                self.effects_applicable[k] = False
166        else:
167            raise TypeError('Potion is depleted.')
168        
169        return tuple(divided_potions)
170    
171    def __getattr__(self, attr):
172        if self.used_in_reaction:
173            raise TypeError('Potion is now part of something bigger than itself.')
174    
175    def __eq__(self, other):
176        sum_self_intens = 0
177        sum_other_intens = 0
178
179        for k, v in self.effects_used.items():
180            if k not in other.effects_used:
181                return False
182            sum_self_intens += self.effects_used[k]
183            sum_other_intens += other.effects_used[k]
184            if sum_self_intens != sum_other_intens:
185                return False
186        return True
187
188    def __lt__(self, other):
189        sum_self_intens = 0
190        sum_other_intens = 0
191        for k, v in self.effects_used.items():
192            sum_self_intens += self.effects_used[k]
193            sum_other_intens += other.effects_used[k]
194        return sum_self_intens < sum_other_intens    
195
196    def __gt__(self, other):
197        sum_self_intens = 0
198        sum_other_intens = 0
199        for k, v in self.effects_used.items():
200            sum_self_intens += self.effects_used[k]
201            sum_other_intens += other.effects_used[k]
202        return sum_self_intens > sum_other_intens
203
204
205class ГоспожатаПоХимия:
206
207    def __init__(self):
208        self.is_pot_depleted = False
209        self.pot_duration = 0
210        self.target_dic = {}
211        self.object = None
212        self.objects = []
213
214    def apply(self, target, potion):
215        if potion not in self.objects:
216            self.target_dic = target.__dict__.copy()
217            new_dict = {}
218            for k, v in potion.effects.items():
219                ascii_sum = sum(ord(char) for char in k)
220                new_dict[ascii_sum] = v
221            sorted_effects = dict(sorted(new_dict.items(), key=lambda x: x[0], reverse=True))
222            for k, v in sorted_effects.items():
223                v(target)
224                
225            for k, v in potion.effects_applicable.items():
226                potion.effects_applicable[k] = False
227
228            self.is_pot_depleted = True
229            self.pot_duration = potion.duration
230            self.object = target
231            self.objects.append(potion)
232            potion.used_in_reaction = True
233
234        else:
235            raise TypeError('Potion is depleted.')
236
237    def tick(self):
238        if self.is_pot_depleted:
239            self.pot_duration -= 1
240            if self.pot_duration == 0:
241                self.object.__dict__ = self.target_dic