Octopusal networks

class Octopus: shocks_threshold = 2 def __init__(self, id): self.id = id self.awake = False self.excitement = 0 self.tentacles = [] def shocked(self, power): self.excitement += power if (self.excitement >= Octopus.shocks_threshold): self.awake = True def detail(self): result = f'{self}\n' for tentacle in self.tentacles: result += f'\t{tentacle}\n' return result def __str__(self): return f'Octopus {self.id} [awake: {self.awake}, excitement: {self.excitement}]'

class Tentacle: def __init__(self, id, owner, connected): self.id = id self.owner = owner self.connected = connected owner.tentacles.append(self) def shock(self): self.connected.shocked(1) def __str__(self): id = self.id owner = self.owner connected = self.connected return f'Tentacle {id}: Octopus {owner.id} -> Octopus {connected.id}'

class Beach: def __init__(self, width, height): self.width = width self.height = height self.octopuses = [] self.create_octopuses() self.connect_neighbours() def create_octopus(self, id): return Octopus(id=id) def create_octopuses(self): for i in range(0, self.width * self.height): octopus = self.create_octopus(id=i) self.octopuses.append(octopus) def create_tentacle(self, id, owner, connected): return Tentacle(id=id, owner=owner, \ connected=connected) def connect_neighbours(self): width = self.width height = self.height def get_neighbours(x, y): neighbours = [] neighbours.append((x - 1, y - 1)) neighbours.append((x - 1, y)) neighbours.append((x - 1, y + 1)) neighbours.append((x, y - 1)) neighbours.append((x, y + 1)) neighbours.append((x + 1, y - 1)) neighbours.append((x + 1, y)) neighbours.append((x + 1, y + 1)) return neighbours for i in range(0, width * height): octopus = self.octopuses[i] coors_neighbours = get_neighbours(i // height, i % width) tentacle_id = 0 for x, y in coors_neighbours: try: neighbour = self.get(x, y) tentacle = self.create_tentacle(id=tentacle_id, owner=octopus, \ connected=neighbour) tentacle_id += 1 except: continue def get(self, x, y,): width = self.width height = self.height if (0 <= x < height) and (0 <= y < width): return self.octopuses[x * width + y] else: raise Exception def detail(self): result = '' for octopus in self.octopuses: result += octopus.detail() return result def __str__(self): result = '\n' for x in range(0, self.height): for y in range(0, self.width): octopus = self.octopuses[x * self.width + y] result += '💡' if octopus.awake else '🐙' result += '\n' return result

beach = Beach(width=4, height=4) print(beach)

from random import shuffle class Helicopter: @staticmethod def light(beach, where): shuffle(where) for x, y in where: octopus = beach.get(x, y) octopus.shocked(Octopus.shocks_threshold)

size = 10 half = int(size / 2) center = [(half, half), (half, half - 1), (half - 1 , half), (half - 1, half - 1)] beach = Beach(width=size, height=size) Helicopter.light(beach, center) print(beach)

class AllSleepingException(Exception): pass class BeachWithSpreading(Beach): def __init__(self, width, height, shocks_threshold=3): super().__init__(width, height) Octopus.shocks_threshold = shocks_threshold def start(self, where): Helicopter.light(self, where) def print_start(self, show): if show: print('Start') print(self) def iteration(self): awake = [o for o in self.octopuses if o.awake] if len(awake) == 0: raise AllSleepingException for octopus in awake: for tentacle in octopus.tentacles: tentacle.shock() def print_iteration(self, show, i): if show: print(f'Iteration {i + 1}') print(self) def animate(self, where=None, iterations=10, show=True): if where != None: self.start(where) self.print_start(show) for i in range(0, iterations): try: self.iteration() self.print_iteration(show, i) except AllSleepingException: if show == True: print('It looks like everyone is sleeping 😕') break

beach = BeachWithSpreading(width=10, height=10) beach.animate(where=center)

class OctopusWithSmell(Octopus): smell_threshold = 20 def __init__(self, id, environment): super().__init__(id) self.environment = environment def shocked(self, power=0): if (self.awake): return self.excitement += power if (self.excitement >= Octopus.shocks_threshold and self.environment.smell < OctopusWithSmell.smell_threshold): self.awake = True self.environment.smell += 1

class BeachWithSmell(BeachWithSpreading): def __init__(self, width, height, shocks_threshold=5, smell_threshold=20): super().__init__(width, height, shocks_threshold) self.smell = 0 OctopusWithSmell.smell_threshold = smell_threshold def create_octopus(self, id): return OctopusWithSmell(id=id, environment=self) def print_iteration(self, show, i): if show: print(f'Iteration {i + 1} - smell: {self.smell}') print(self)

beach = BeachWithSmell(width=10, height=10) beach.animate(center)

class TentacleWithSoreness(Tentacle): def __init__(self, id, owner, connected): super().__init__(id, owner, connected) self.soreness = 1 def shock(self): if self.connected.awake: self.soreness += 1 else: self.connected.shocked(self.soreness) def __str__(self): return super().__str__() + f': Soreness {self.soreness}'

class BeachWithSoreness(BeachWithSmell): def __init__(self, width, height, shocks_threshold=50, smell_threshold=50): super().__init__(width, height, shocks_threshold, smell_threshold) def create_tentacle(self, id, owner, connected): return TentacleWithSoreness(id=id, owner=owner, \ connected=connected) def print_night(self): print() print("Night\n") for i in range(0, self.height): print("🌚" * self.width) print("\n") def night(self, show=False): for octopus in self.octopuses: if octopus.awake: self.smell -= 1 octopus.awake = False octopus.excitement = 0 if show: self.print_night()

size = 10 half = int(size / 2) L_form_horizontal = [] L_form_vertical = [] for x in range(0 + half // 2, size - half // 2): L_form_vertical.append((x, half // 2)) L_form_vertical.append((x, half // 2 - 1)) for y in range(0 + half // 2, size - half // 2): L_form_horizontal.append((half + half // 2, y)) L_form_horizontal.append((half + half // 2 - 1, y)) L_form = L_form_vertical + L_form_horizontal beach = BeachWithSoreness(width=10, height=10) beach.animate(L_form, show=False) beach.night(show=False) beach.animate(L_form_vertical, iterations=11, show=True)

class OctopusWithTiredness(OctopusWithSmell): tiredness_threshold = 10 recovery_threshold = 10 def __init__(self, id, environment): super().__init__(id, environment) self.tiredness = 0 self.recovering = False self.recover_status = 0 def tired(self): self.tiredness += 1 if (self.tiredness > OctopusWithTiredness.tiredness_threshold): self.sleep(night=False) def recover(self): self.recover_status += 1 if (self.recover_status >= OctopusWithTiredness.recovery_threshold): self.recovering = False self.recover_status = 0 def shocked(self, power=0): if not self.recovering: super().shocked(power) def sleep(self, night=True): if self.awake: self.environment.smell -= 1 self.awake = False self.excitement = 0 self.tiredness = 0 if night: self.recovering = False self.recover_status = 0 else: self.recovering = True

from random import shuffle class BeachWithTiredness(BeachWithSoreness): def __init__(self, width, height, shocks_threshold=80, smell_threshold=50, tiredness_threshold=5, recovery_threshold=5): super().__init__(width, height, shocks_threshold, smell_threshold) OctopusWithTiredness.tiredness_threshold = tiredness_threshold OctopusWithTiredness.recovery_threshold = recovery_threshold def create_octopus(self, id): return OctopusWithTiredness(id=id, environment=self) def iteration(self): awake = [o for o in self.octopuses if o.awake] if len(awake) == 0: raise AllSleepingException shuffle(awake) for octopus in awake: octopus.tired() for tentacle in octopus.tentacles: tentacle.shock() recovering = [o for o in self.octopuses if o.recovering] for octopus in recovering: octopus.recover() def night(self, show=False): for octopus in self.octopuses: octopus.sleep() if show: self.print_night()

size = 10 half = int(size / 2) L_form_horizontal = [] L_form_vertical = [] for x in range(0 + half // 2, size - half // 2): L_form_vertical.append((x, half // 2)) L_form_vertical.append((x, half // 2 - 1)) for y in range(0 + half // 2, size - half // 2): L_form_horizontal.append((half + half // 2, y)) L_form_horizontal.append((half + half // 2 - 1, y)) L_form = L_form_vertical + L_form_horizontal beach = BeachWithTiredness(width=10, height=10, tiredness_threshold=15) beach.animate(L_form, show=False) beach.night(show=False) beach.animate(L_form_vertical, iterations=20, show=True)

class OctopusWithListeners(OctopusWithTiredness): def __init__(self, id, environment): super().__init__(id, environment) self.listeners = [] def attach_listener(self, listener): self.listeners.append(listener) def fire_listeners(self): for listener in self.listeners: listener.fire(self) def shocked(self, power=0): was_awake = self.awake super().shocked(power) is_awake = self.awake if (not was_awake and is_awake): self.fire_listeners() def tired(self): was_awake = self.awake super().tired() is_awake = self.awake if (was_awake and not is_awake): self.fire_listeners()

class BeachWithListeners(BeachWithTiredness): def __init__(self, width, height, shocks_threshold=80, smell_threshold=50, tiredness_threshold=5, recovery_threshold=5): super().__init__(width, height, shocks_threshold, smell_threshold, tiredness_threshold, recovery_threshold) self.listeners = set([]) def create_octopus(self, id): return OctopusWithListeners(id=id, environment=self) def attach_listener(self, where, listener): self.listeners.add(listener) for x, y in where: octopus = self.get(x, y) octopus.attach_listener(listener) def night(self, show=False): super().night() for listener in self.listeners: listener.reset()

class NumberListener(): def __init__(self, number): self.threshold = 16 self.number = number def reset(self): self.threshold = 16 def fire(self, octopus): if octopus.awake: self.threshold -= 1 else: self.threshold += 1 if (self.threshold == 0): print(self.number) self.threshold = 16 from numbers_patterns import * beach = BeachWithListeners( width=28, height=28, tiredness_threshold=10, recovery_threshold=30, smell_threshold=16 + 16 + 12, shocks_threshold=60 ) beach.animate(one + after1 + two, iterations=10, show=False) beach.night(show=False) beach.animate(two + after2 + three, iterations=10, show=False) beach.night(show=False) beach.animate(three + after3 + four, iterations=10, show=False) beach.night(show=False) beach.animate(four + after4 + five, iterations=10, show=False) beach.night(show=False) beach.animate(five + after5 + six, iterations=10, show=False) beach.night(show=False) beach.animate(six + after6 + seven, iterations=10, show=False) beach.night(show=False) beach.animate(seven + after7 + eight, iterations=10, show=False) beach.night(show=False) beach.animate(eight + after8 + nine, iterations=10, show=False) beach.night(show=False) beach.attach_listener(one, NumberListener(1)) beach.attach_listener(two, NumberListener(2)) beach.attach_listener(three, NumberListener(3)) beach.attach_listener(four, NumberListener(4)) beach.attach_listener(five, NumberListener(5)) beach.attach_listener(six, NumberListener(6)) beach.attach_listener(seven, NumberListener(7)) beach.attach_listener(eight, NumberListener(8)) beach.attach_listener(nine, NumberListener(9)) OctopusWithSmell.smell_threshold = 16 + 12 beach.animate(one, iterations=210, show=False) beach.night()