1import copy
  2
  3
  4class EffectWrapper:
  5    """Effect decorator to handle intensity and single-usage."""
  6
  7    def __init__(self, function, intensity):
  8        """Initializator."""
  9        self.function = function
 10        self.intensity = intensity
 11        self.depleted = False
 12
 13    def __call__(self, target):
 14        """Wrapper of the decorated function."""
 15        if self.depleted:
 16            raise TypeError("Effect is depleted.")
 17        self.depleted = True
 18        for _ in range(self.intensity):
 19            self.function(target)
 20
 21
 22class Potion:
 23    """Potion representation."""
 24
 25    def __init__(self, effects, duration, intensities=None):
 26        """Initializator."""
 27        self.effects = effects
 28        self.duration = duration
 29        self.deprecated = False
 30        self.depleted = False
 31        self.intensities = intensities or {}
 32        for key, val in effects.items():
 33            self.intensities.setdefault(key, 1)
 34            setattr(self, key, EffectWrapper(val, self.intensities[key]))
 35
 36    def __getattribute__(self, name):
 37        """Prevent usage if the potion is deprecated."""
 38        try:
 39            if object.__getattribute__(self, 'depleted'):
 40                raise TypeError("Potion is depleted.")
 41            if object.__getattribute__(self, 'deprecated'):
 42                raise TypeError("Potion is now part of something bigger than itself.")
 43            if type(object.__getattribute__(self, name)) is EffectWrapper:
 44                object.__getattribute__(self, 'intensities')[name] = 0
 45        except AttributeError:
 46            pass # deepcopy starts using this code before depleted and deprecated are available
 47        return object.__getattribute__(self, name)
 48
 49    @staticmethod
 50    def round_down(val):
 51        """Round x.5 down, other cases - as normal."""
 52        if val % 1 <= 0.5:
 53            return int(val)
 54        return int(val) + 1
 55
 56    def __add__(self, other):
 57        """Combinations."""
 58        effects = {}
 59        intensities = {}
 60        duration = max(self.duration, other.duration)
 61        for key, val in self.effects.items():
 62            intensities[key] = self.intensities[key]
 63            effects[key] = val
 64        for key, val in other.effects.items():
 65            intensities[key] = intensities.get(key, 0) + other.intensities[key]
 66            effects[key] = val
 67        self.deprecated = True
 68        other.deprecated = True
 69        return Potion(effects, duration, intensities)
 70
 71    def __mul__(self, other):
 72        """Potentiation/Dilution."""
 73        effects = {}
 74        intensities = {}
 75        duration = self.duration
 76        for key, val in self.effects.items():
 77            intensities[key] = self.round_down(self.intensities[key] * other)
 78            effects[key] = val
 79        self.deprecated = True
 80        return Potion(effects, duration, intensities)
 81
 82    def __sub__(self, other):
 83        """Purification."""
 84        effects = {}
 85        intensities = {}
 86        duration = self.duration
 87        if set(other.effects) - set(self.effects):
 88            raise TypeError('Effect mismatch.')
 89        for key, val in self.effects.items():
 90            if (intensity := self.intensities[key] - other.intensities.get(key, 0)) > 0:
 91                intensities[key] = intensity
 92                effects[key] = val
 93        self.deprecated = True
 94        other.deprecated = True
 95        return Potion(effects, duration, intensities)
 96
 97    def __truediv__(self, other):
 98        """Separation."""
 99        effects = {}
100        intensities = {}
101        duration = self.duration
102        for key, val in self.effects.items():
103            intensities[key] = self.round_down(self.intensities[key] / other)
104            effects[key] = val
105        self.deprecated = True
106        return tuple([Potion(effects, duration, intensities) for _ in range(other)])
107
108    def __eq__(self, other):
109        """Equal."""
110        return self.intensities == other.intensities
111    
112    def __lt__(self, other):
113        """Less than."""
114        return sum(self.intensities.values()) < sum(other.intensities.values())
115
116
117class ГоспожатаПоХимия:
118    """Химичка Димитричка."""
119
120    def __init__(self):
121        """Initializator."""
122        self._target_cache = {}
123        self._potions_stack = {}
124    
125    def _cache_target(self, target):
126        """Cache all public properties of a target."""
127        if target in self._target_cache:
128            return False
129        self._target_cache[target] = {}
130        for key, val in vars(target).items():
131            if key.startswith('_'):
132                continue
133            self._target_cache[target][key] = copy.deepcopy(val)
134
135    def _apply_potion(self, target, potion):
136        """Apply a potion to a target."""
137        potion_copy = copy.deepcopy(potion)
138        sorted_effects = sorted(potion.effects.keys(),
139                                key=lambda x: sum(map(ord, x)),
140                                reverse=True)
141        for key in sorted_effects:
142            try:
143                getattr(potion, key)(target)
144            except TypeError:
145                pass # This effect is not available
146        potion.depleted = True
147        return potion_copy
148
149    def _apply_all_potions(self, target):
150        """Apply all potions to a target one by one."""
151        # Set initial state
152        for attr_key, attr_val in self._target_cache[target].items():
153            setattr(target, attr_key, copy.deepcopy(attr_val))
154        # Apply all active potions
155        # and replace the used potion with a potion ready to be used again
156        if target in self._potions_stack:
157            for i, potion in enumerate(self._potions_stack[target]):
158                potion_copy = self._apply_potion(target, potion)
159                self._potions_stack[target][i] = potion_copy
160
161    def apply(self, target, potion):
162        """Apply a potion to a target."""
163        # Ensure potion is not depleted by trying to get an attribute
164        # Depleted potion will raise a TypeError if it is depleted
165        potion.depleted
166        self._cache_target(target)
167        self._potions_stack.setdefault(target, []).append(potion)
168        self._apply_all_potions(target)
169    
170    def tick(self):
171        """Tick a turn."""
172        for target, potion_stack in self._potions_stack.items():
173            new_potion_stack = []
174            for potion in potion_stack:
175                potion.duration -= 1
176                if potion.duration > 0:
177                    new_potion_stack.append(potion)
178            self._potions_stack[target] = new_potion_stack
179            self._apply_all_potions(target)
180            if not len(new_potion_stack):
181                del self._target_cache[target]
182        self._potions_stack = {key: val for key, val in self._potions_stack.items() if val}
183
184
185
186class Target:
187    """Test target."""
188
189    def __init__(self, **kwargs):
190        """Initializator."""
191        self._cache = kwargs
192        for key, val in kwargs.items():
193            setattr(self, key, val)