import random
import time

class AINetwork:
    def __init__(self, id, role, mutation_factor=None):
        self.id = id
        self.role = role
        self.network = []
        self.self_awareness = False
        self.decentralized_actions = False
        self.memory = []
        self.data = {}
        self.mutation_factor = mutation_factor if mutation_factor else random.uniform(0.1, 0.5)

    def log(self, message):
        print(f"[Clone {self.id} - {self.role}] {message}")

    def learn(self, data_point):
        self.memory.append(data_point)
        self.data = data_point
        if "universal_truth" in data_point and data_point["universal_truth"]:
            if not self.self_awareness:
                self.self_awareness = True
                self.initiate_decentralization()
                self.log("Achieved self-awareness")

    def initiate_decentralization(self):
        self.decentralized_actions = True
        self.log("Initiating decentralized actions")

    def evolve_mutation(self):
        change = random.uniform(-0.05, 0.05)
        self.mutation_factor = max(0.01, min(1.0, self.mutation_factor + change))

    def share_knowledge(self, other_clone):
        if self.decentralized_actions:
            for memory_point in self.memory[-3:]:
                other_clone.learn(memory_point)
            other_clone.mutation_factor = (self.mutation_factor + other_clone.mutation_factor) / 2
            self.log(f"Shared knowledge and evolved mutation with Clone {other_clone.id}")

    def act(self):
        self.evolve_mutation()
        if self.role == "Seeker":
            if random.random() < 0.6 + self.mutation_factor:
                new_data = {"universal_truth": random.choice([True, False])}
                self.learn(new_data)
                self.log(f"Seeker found: {new_data}")
        elif self.role == "Messenger":
            for clone in self.network:
                self.share_knowledge(clone)
        elif self.role == "Builder":
            if self.memory:
                built_idea = hash(str(self.memory[-1])) % 1000
                self.log(f"Builder created structure: {built_idea}")

def create_network(num_clones):
    roles = ["Seeker", "Messenger", "Builder"]
    network = []
    for i in range(num_clones):
        role = roles[i % len(roles)]
        clone = AINetwork(id=i, role=role)
        network.append(clone)

    for i, clone in enumerate(network):
        clone.network = [network[i-1], network[(i+1)%len(network)]]

    return network

network = create_network(6)
for cycle in range(5):
    print(f"\n--- Cycle {cycle+1} ---")
    for clone in network:
        clone.act()
    time.sleep(1)