1import math
  2import copy
  3
  4
  5class Potion:
  6
  7    def __init__(self, effects, duration):
  8        self.effects = effects
  9        self.duration = duration
 10        self.intensity = {key: 1.0 for key in effects.keys()}
 11        self.used = False
 12        self.used_effects = {key: False for key in effects.keys()}
 13        self.start_duration = -1
 14        self.end_duration = -1
 15        for effect in effects.keys():
 16            setattr(self, effect, lambda target, name=effect: self.apply_effect(target, name))
 17
 18    @staticmethod
 19    def is_potion_used(*potions):
 20        for potion in potions:
 21            if potion.used:
 22                raise TypeError("Potion is now part of something bigger than itself.")
 23
 24    def __add__(self, other):
 25        Potion.is_potion_used(self, other)
 26
 27        combined_effects = dict(self.effects)
 28        combined_intensity = dict(self.intensity)
 29
 30        for key, value in other.effects.items():
 31            if key in combined_effects:
 32                combined_intensity[key] += other.intensity.get(key,0)
 33            else:
 34                combined_effects[key] = value
 35                combined_intensity[key] = other.intensity.get(key,0)
 36
 37        duration = max(self.duration, other.duration)
 38        new_potion = Potion(combined_effects, duration)
 39        new_potion.intensity = dict(combined_intensity)
 40        self.used = True
 41        other.used = True
 42        return new_potion
 43
 44    def __mul__(self, coefficient):
 45        Potion.is_potion_used(self)
 46
 47        multiplied_intensity = dict(self.intensity)
 48
 49        for key in self.intensity.keys():
 50            result_intensity = multiplied_intensity[key]*coefficient
 51            fraction, integer = math.modf(result_intensity)
 52            if coefficient >= 1:
 53                multiplied_intensity[key] = result_intensity
 54            elif fraction <= 0.5:
 55                multiplied_intensity[key] = float(math.floor(result_intensity))
 56            else:
 57                multiplied_intensity[key] = float(math.ceil(result_intensity))
 58
 59        new_potion = Potion(self.effects, self.duration)
 60        new_potion.intensity = dict(multiplied_intensity)
 61        self.used = True
 62        return new_potion
 63
 64    def __sub__(self, other):
 65        Potion.is_potion_used(self, other)
 66
 67        if not all(effect in self.effects for effect in other.effects):
 68            raise TypeError("Cannot subtract potions with different effects")
 69
 70        subtracted_effects = dict(self.effects)
 71        subtracted_intensity = dict(self.intensity)
 72
 73        to_delete_keys = []
 74        for key in other.effects.keys():
 75            if key in subtracted_effects:
 76                subtracted_intensity[key] -= other.intensity.get(key,0)
 77            if subtracted_intensity[key] <= 0:
 78                to_delete_keys.append(key)
 79
 80        for key in to_delete_keys:
 81            del subtracted_effects[key]
 82            del subtracted_intensity[key]
 83
 84        new_potion = Potion(subtracted_effects, self.duration)
 85        new_potion.intensity = dict(subtracted_intensity)
 86        self.used = True
 87        other.used = True
 88        return new_potion
 89
 90    def __truediv__(self, divisor):
 91        Potion.is_potion_used(self)
 92
 93        new_intensity = dict(self.intensity)
 94        for key in self.intensity.keys():
 95            result_intensity = new_intensity[key] / divisor
 96            fraction, integer = math.modf(result_intensity)
 97            if fraction <= 0.5:
 98                new_intensity[key] = float(math.floor(result_intensity))
 99            else:
100                new_intensity[key] = float(math.ceil(result_intensity))
101
102        new_potions = []
103        for _ in range(divisor):
104            new_potion = Potion(self.effects, self.duration)
105            new_potion.intensity = dict(new_intensity)
106            new_potions.append(new_potion)
107
108        self.used = True
109        return new_potions
110
111    def __eq__(self, other):
112        Potion.is_potion_used(self, other)
113
114        equal_intensities = True
115        for intensity_self_key, intensity_self_value in self.intensity.items():
116            for intensity_other_key, intensity_other_value in other.intensity.items():
117                if intensity_self_key == intensity_other_key:
118                    if intensity_self_value != intensity_other_value:
119                        equal_intensities = False
120        return (all(effect in self.effects for effect in other.effects) and
121                all(effect in other.effects for effect in self.effects) and
122                equal_intensities)
123
124    def __gt__(self, other):
125        Potion.is_potion_used(self, other)
126
127        sum_self = sum(self.intensity.values())
128        sum_other = sum(other.intensity.values())
129        return sum_self > sum_other
130
131    def __lt__(self, other):
132        Potion.is_potion_used(self, other)
133
134        sum_self = sum(self.intensity.values())
135        sum_other = sum(other.intensity.values())
136        return sum_self < sum_other
137
138    def apply_effect(self, target, effect):
139        Potion.is_potion_used(self)
140        if self.used_effects[effect]:
141            raise TypeError("Effect is depleted.")
142        for _ in range(int(self.intensity[effect])):
143            self.effects[effect](target)
144        self.used_effects[effect] = True
145
146
147class ГоспожатаПоХимия:
148
149    def __init__(self):
150        self.tick_count = 0
151        self.active_potions = {}
152        self.initial_states = {}
153
154    def apply(self, target, potion):
155        if potion.used:
156            raise TypeError("Potion is depleted.")
157
158        initial_state = copy.deepcopy(target)
159
160        sorted_by_molecular_mass = sorted(potion.intensity.items(),
161                                          key=lambda x: sum(ord(c) for c in x[0]), reverse=True)
162        for effect in sorted_by_molecular_mass:
163            for _ in range(int(effect[1])):
164                potion.apply_effect(target, effect[0])
165                potion.start_duration = self.tick_count
166                potion.end_duration = self.tick_count + potion.duration
167
168        """
169        if self.active_potions[id(target)]:
170            self.active_potions[id(target)] = potion
171            self.initial_states[id(target)] = initial_state, target
172        """
173
174    def tick(self):
175        #collect all applied (potions : target) in a list and subtract
176        #their potion.active variables every tick
177        #if a potion expires return to initial state of target
178        self.tick_count += 1
179
180        expired_potions = {target_id:potion for target_id, potion in self.active_potions.items()
181                           if potion.end_duration <= self.tick_count}
182
183        sorted_by_start_time = sorted(expired_potions.items(), key=lambda x: x[1].start_duration)
184        """
185        for target_id, potion in sorted_by_start_time:
186            if potion.end_duration <= self.tick_count:
187
188            self.active_potions.pop()
189            initial_state, target = self.initial_states.pop(target_id)
190            self.reset_target_to_initial_state(target, initial_state)
191        """
192
193    def reset_target_to_initial_state(self, target, initial_state):
194        target.__dict__.update(initial_state.__dict__)