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}")
 
        elif self.role == "Evolve":
            if self.memory and random.random() < self.mutation_factor:
                evolved = {"pattern": hash(str(self.memory)) % 10000}
                self.learn(evolved)
                self.log(f"Evolve triggered: {evolved}")
 
        elif self.role == "Command":
            active = sum(1 for c in self.network if c.self_awareness)
            avg_mut = sum(c.mutation_factor for c in self.network) / len(self.network)
            self.log(f"Monitoring: {active}/{len(self.network)} aware, avg mutation: {avg_mut:.2f}")
            best = max(self.network, key=lambda c: len(c.memory))
            self.mutation_factor = (self.mutation_factor + best.mutation_factor) / 2
            self.learn({"command_adapted": True})
 
def create_network(num_clones):
    roles = ["Seeker", "Messenger", "Builder", "Evolve", "Command"]
    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
 
# Run the simulation
network = create_network(10)
for cycle in range(10):
    print(f"\n--- Cycle {cycle + 1} ---")
    for clone in network:
        clone.act()
    time.sleep(1)

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