1import math
  2import copy
  3
  4class Potion:
  5    
  6    def __init__(self, effects, duration, is_part_of_bigger = False, is_applied = False):
  7        self.duration = duration
  8        self.is_part_of_bigger = is_part_of_bigger
  9        self.is_applied = is_applied
 10        
 11        self.effects = {}
 12        for name, func in effects.items():
 13            if name in self.effects:
 14                self.effects[name].intensity += 1
 15            else:
 16                self.effects[name] = Effect(name, func)
 17                
 18    def check_potions(self, other = None):
 19        if self.is_applied is True:
 20            raise TypeError("Potion is depleted")
 21        if self.is_part_of_bigger is True:
 22            raise TypeError("Potion is now part of something bigger than itself.")
 23        
 24        if other is not None:
 25            if other.is_part_of_bigger is True:
 26                raise TypeError("Potion is now part of something bigger than itself.")
 27            if other.is_applied is True:
 28                raise TypeError("Potion is depleted")
 29    
 30    def __getattr__(self, name):
 31        if name in self.effects:
 32            self.check_potions()
 33            return self.effects[name]
 34        else:
 35            raise AttributeError
 36        
 37    def __add__(self, other):
 38        self.check_potions(other)
 39            
 40        self.is_part_of_bigger = True
 41        other.is_part_of_bigger = True
 42        
 43        if self.duration > other.duration:
 44            new_duration = self.duration
 45        else:
 46            new_duration = other.duration
 47            
 48        new_potion = Potion({}, new_duration)
 49        for name, func in other.effects.items():
 50            new_potion.effects[name] = copy.deepcopy(other.effects[name])
 51                
 52        for name, func in self.effects.items():
 53            if name in new_potion.effects:
 54                new_potion.effects[name].intensity += self.effects[name].intensity
 55            else:
 56                new_potion.effects[name] = copy.deepcopy(self.effects[name])
 57                
 58        return new_potion
 59    
 60    
 61    def __sub__(self, other): 
 62        self.check_potions(other)
 63        
 64        self.is_part_of_bigger = True
 65        other.is_part_of_bigger = True
 66        new_potion = Potion({}, self.duration)
 67        
 68        for name, func in self.effects.items():
 69            new_potion.effects[name] = copy.deepcopy(self.effects[name])
 70        
 71        for name in other.effects.keys():
 72            if name in new_potion.effects:
 73                new_potion.effects[name].intensity -= other.effects[name].intensity
 74                if new_potion.effects[name].intensity <= 0:
 75                    del new_potion.effects[name]
 76            else:
 77                raise TypeError("Invalid purification")
 78        
 79        return new_potion
 80        
 81        
 82    def __mul__(self, num): 
 83        self.check_potions()
 84        
 85        self.is_part_of_bigger = True
 86        new_potion = Potion({}, self.duration)
 87        
 88        for name, func in self.effects.items():
 89            new_potion.effects[name] = copy.deepcopy(self.effects[name])
 90        
 91        if isinstance(num, int):
 92            for name in self.effects.keys():
 93                new_potion.effects[name].intensity *= num
 94        else:
 95            for name in self.effects.keys():
 96                new_intensity = new_potion.effects[name].intensity * num
 97                if new_intensity - int(new_intensity) <= 0.5:
 98                    new_intensity = math.floor(new_intensity)
 99                else:
100                    new_intensity = math.ceil(new_intensity)
101                new_potion.effects[name].intensity = new_intensity
102                   
103        return new_potion
104        
105    def __truediv__(self, num):
106        self.check_potions()
107        
108        self.is_part_of_bigger = True
109        
110        new_potion = Potion({}, self.duration)
111        
112        for name, func in self.effects.items():
113            new_potion.effects[name] = copy.deepcopy(self.effects[name])
114        
115        for name in self.effects.keys():
116            new_intensity = new_potion.effects[name].intensity / num
117            if new_intensity - int(new_intensity) <= 0.5:
118                new_intensity = math.floor(new_intensity)
119            else:
120                new_intensity = math.ceil(new_intensity)
121            new_potion.effects[name].intensity = new_intensity
122            
123        return tuple(new_potion for _ in range(num))
124                
125    def __eq__(self, other):
126        self.check_potions(other)
127        
128        if self.effects.keys() != other.effects.keys():
129            return False
130        
131        for name in self.effects.keys():
132            if not (self.effects[name] == other.effects[name]):
133                 return False
134        
135        return True
136        
137    def __lt__(self, other):
138        self.check_potions(other)
139        
140        my_int = 0
141        other_int = 0
142        
143        for name in self.effects.keys():
144            my_int += self.effects[name].intensity
145            
146        for name in other.effects.keys():
147            other_int += other.effects[name].intensity
148            
149        return my_int < other_int
150    
151    def __gt__(self, other):
152        self.check_potions(other)
153        return not self.__lt__(other) and not self.__eq__(other)
154        
155        
156class Effect:
157    
158    def __init__(self, name, func, intensity = 1, used = False):
159        self.name = name
160        self.func = func
161        self.intensity = intensity
162        self.used = used
163        self.molecule = sum(ord(char) for char in name)
164        
165    def __call__(self, args):
166        if self.used is True:
167            raise TypeError("Effect is depleted")
168        for count in range(self.intensity):
169            self.func(args)
170            
171        self.used = True
172        
173    def __eq__(self, other):
174        if self.name != other.name:
175            return False
176        if self.func != other.func:
177            return False
178        if self.intensity != other.intensity:
179            return False
180        return True
181    
182class ГоспожатаПоХимия:
183            
184    #def __init__(self)
185    
186    def tick(self):
187        #to do
188        pass
189        
190    def apply(self, target, potion):
191        potion.check_potion()
192        
193        potion.effects = dict(sorted(potion.effects.items(), key=lambda item: item[1].molecule))
194        
195        for name in potion.effects.keys():
196            if potion.effects[name].used == False:
197                for count in range(potion.effects[name].intensity):
198                    potion.effects[name](target)
199                                             
200        potion.is_applied = True
201