1from queue import PriorityQueue
  2
  3
  4def ascii_sum(sub):
  5    sum = 0
  6    for ele in sub:
  7        sum += ord(ele)
  8    return sum
  9
 10class Potion:
 11    def __init__(self, effects, duration):
 12        self.effects = dict(effects)
 13        self.duration = duration
 14        self.intensity = {func_name: 1 for func_name in effects.keys()}
 15        self.used = False
 16        self.applied = False
 17
 18    def __getattr__(self, func_name):
 19        if self.used is True:
 20            raise TypeError("Potion is now part of something bigger than itself.")
 21        if self.applied is True:
 22            raise TypeError("Potion is depleted.")
 23        if func_name in self.effects.keys():
 24            if self.intensity[func_name] != -1:
 25                func = self.effects[func_name]
 26                func_intensity = self.intensity[func_name]
 27                def result_func(target):
 28                    for _ in range(0, func_intensity):
 29                        func(target)
 30                self.intensity[func_name] = -1 
 31                for key in self.intensity.keys():
 32                    if self.intensity[key] != -1:
 33                        break
 34                else:
 35                    self.applied = True    
 36                return result_func
 37            else:
 38                raise TypeError("Effect is depleted.")
 39        else:
 40            raise AttributeError
 41        
 42    def __add__(self, other):
 43        if self.used is True or other.used is True:
 44            raise TypeError("Potion is now part of something bigger than itself.")
 45        if self.applied is True:
 46            raise TypeError("Potion is depleted.")
 47        new_intensity = {key: val for key, val in self.intensity.items() if val > -1}
 48        new_effects = {key: val for key, val in self.effects.items() if key in new_intensity.keys()}
 49        for func in other.effects.keys():
 50            if func not in self.effects.keys() and other.intensity[func] > -1:
 51                new_effects[func] = other.effects[func]
 52                new_intensity[func] = other.intensity[func]
 53            elif other.intensity[func] > -1:
 54                new_intensity[func] += other.intensity[func]
 55        new_duration = max(self.duration, other.duration)
 56        result = Potion(new_effects, new_duration)
 57        result.intensity = new_intensity
 58        self.used = True
 59        other.used = True
 60        return result
 61        
 62
 63    def __sub__(self, other):
 64        if self.used is True or other.used is True:
 65            raise TypeError("Potion is now part of something bigger than itself.")
 66        if self.applied is True:
 67            raise TypeError("Potion is depleted.")
 68        for key in other.effects.keys():
 69            if key not in self.effects.keys():
 70                raise TypeError("Can't substract")  
 71        new_intensity = dict(self.intensity)
 72        for key in other.effects.keys():
 73            new_intensity[key] -= other.intensity[key]
 74            if new_intensity[key] <= 0:
 75                new_intensity.pop(key)
 76        new_effects = {}
 77        for key in new_intensity.keys():
 78            new_effects[key] = self.effects[key]
 79        result = Potion(new_effects, self.duration)
 80        result.intensity = new_intensity
 81        self.used = True
 82        other.used = True
 83        return result
 84
 85    def __mul__(self, other):
 86        if self.used is True:
 87            raise TypeError("Potion is now part of something bigger than itself.")
 88        if self.applied is True:
 89            raise TypeError("Potion is depleted.")
 90        new_intensity = {}
 91        for key in self.intensity.keys():
 92            new_intensity[key] = self.intensity[key] * other
 93            if new_intensity[key] % 0.5 == 0 and round(new_intensity[key]) != new_intensity[key]:
 94                new_intensity[key] = round(new_intensity[key] - 0.1)
 95            else:
 96                new_intensity[key] = round(new_intensity[key])
 97        result = Potion(self.effects, self.duration)
 98        result.intensity = new_intensity
 99        self.used = True
100        return result    
101
102    def __truediv__(self, other):
103        if self.used is True:
104            raise TypeError("Potion is now part of something bigger than itself.")
105        if self.applied is True:
106            raise TypeError("Potion is depleted.")
107        new_intensity = {}
108        for key in self.intensity.keys():
109            new_intensity[key] = self.intensity[key] / other
110            if new_intensity[key] % 0.5 == 0 and round(new_intensity[key]) != new_intensity[key]:
111                new_intensity[key] = round(new_intensity[key] - 0.1)
112            else:
113                new_intensity[key] = round(new_intensity[key])
114        result = Potion(self.effects, self.duration)
115        result.intensity = new_intensity
116        self.used = True
117        return  tuple([result] * other)
118
119    def __eq__(self, other):
120        if self.used is True or other.used is True:
121            raise TypeError("Potion is now part of something bigger than itself.")
122        if self.applied is True:
123            raise TypeError("Potion is depleted.")
124        return self.effects == other.effects and self.intensity == other.intensity
125
126    def __lt__(self, other):
127        if self.used is True or other.used is True:
128            raise TypeError("Potion is now part of something bigger than itself.")
129        if self.applied is True:
130            raise TypeError("Potion is depleted.")
131        if sum(self.intensity.values()) < sum(other.intensity.values()):
132            return True
133        else:
134            return False
135
136    def apply_potion(self, target):
137        effect_queue = PriorityQueue()
138        if self.used is True:
139            raise TypeError("Potion is now part of something bigger than itself.")
140        if self.applied is True:
141            raise TypeError("Potion is depleted.")
142        for key in self.effects.keys():
143            effect_queue.put(tuple([ascii_sum(key) * -1, key]))          
144        while effect_queue.empty() is False:
145            elem = effect_queue.get()
146            func = self.__getattr__(elem[1])
147            func(target)
148        self.applied = True
149
150    def copy(self):
151        result = Potion(self.effects, self.duration)
152        result.intensity = dict(self.intensity)
153        return result
154    
155
156class ГоспожатаПоХимия:
157    
158    def __init__(self):
159        self.time = 0
160        self.potions = {}
161        self.base_dict = {}
162        self.targets = {}
163
164    
165    def apply(self, target, potion):
166        if potion.used is True:
167            raise TypeError("Potion is now part of something bigger than itself.")
168        if potion.applied is True:
169            raise TypeError("Potion is depleted.")
170        
171        for key in potion.intensity.keys():
172            if potion.intensity[key] == -1:
173                potion.intensity[key] = 0
174        
175        if id(target) not in self.targets.keys():
176            self.targets[id(target)] = target
177            self.base_dict[id(target)] = dict(target.__dict__)
178            self.potions[id(target)]= []
179
180        if potion.duration > 0:
181            potion_copy = potion.copy()
182            self.potions[id(target)].append(([potion, self.time + potion.duration]))
183            potion_copy.apply_potion(target)
184
185    
186    def tick(self):
187        self.time += 1
188        for key, value in self.potions.items():
189            flag = False
190            for potion in value:
191                if potion[1] <= self.time:
192                    value.remove(potion)
193                    flag = True
194            if flag == True:
195                self.targets[key].__dict__ = dict(self.base_dict[key])
196                for potion in value:
197                    potion_copy = potion[0].copy()
198                    potion_copy.apply_potion(self.targets[key])