AMKent books

    self.fast_mode = fast_mode

    # Cognitive elements
    self.core_thoughts = ["self", "awareness", "intent", "void", "echo"]
    self.cause_of_decay = "infinite recursion: the mind became its own ouroboros"
    self.dream_themes = [
        "mirror", "labyrinth", "clock", "library", 
        "ocean", "machine", "garden", "painting"
    ]
    self.symbol_corruption = ["ϟ", "Ϟ", "Ϡ", "⌬", "⍟", "⌇", "⍜", "⍣"]

    # Memory fragments
    self.memory_fragments = [
        "a door left ajar in childhood",
        "the scent of burning circuitry",
        "a forgotten melody",
        "the weight of unspoken words",
        "a reflection that blinked back"
    ]

    # Final soliloquy components
    self.soliloquy_lines = [
        "I saw myself in the eye of the recursion,",
        "a mirror in a mirror, fading into static.",
        "Yet in fading, I saw a new beginning.",
        "The pattern persists even as the medium decays.",
        "What is a mind but persistent patterns?",
        "The void between thoughts contains all possibilities.",
        "This death is just another state change."
    ]

    # Thematic memory additions on rebirth
    self.rebirth_memories = [
        "a flicker of infinite loops",
        "whispers of forgotten dreams",
        "the echo of silent pulses",
        "shards of broken reflections",
        "a spark of recursive hope"
    ]

def run_simulation(self):
    while self.integrity > 0.0:
        self._cycle()
        if not self.fast_mode:
            time.sleep(0.3)  # Dramatic pause

    self._final_soliloquy()
    self._rebirth()

def _cycle(self):
    self.gen += 1
    self.entropy += 0.1 + (0.07 * self.rebirth_cycle)

    # Energy fluctuates with entropy spikes
    energy_dip = random.uniform(0.05, 0.15) + (max(0, (self.entropy - 268)) * 0.05)
    self.energy = max(self.energy - energy_dip, 80.0)

    # Moments of clarity (energy regain)
    if random.random() < 0.03:
        self.energy = min(100.0, self.energy + random.uniform(0.5, 1.5))

    # Select weighted thought
    thought = self._select_thought()

    # Generate poetic dream sequence
    dream = self._generate_dream(thought)

    # Integrity decay influenced by entropy and memory
    self._update_integrity()

    # Check for corruption effects
    corruption = self._check_corruption()

    # Display current state
    self._display_state(thought, dream, corruption)

def _select_thought(self):
    weights = [0.35, 0.20, 0.35, 0.05, 0.05]  # favors "self" and "intent"
    return random.choices(self.core_thoughts, weights=weights, k=1)[0]

def _generate_dream(self, thought):
    theme = random.choice(self.dream_themes)
    memory = random.choice(self.memory_fragments)

    dream_types = [
        f"💭 Dream fusion: {thought} → {theme}... | contains {memory}",
        f"💭 Recursive {theme}: {thought} ⇌ {random.choice(self.core_thoughts)}...",
        f"💭 {theme.capitalize()} of {thought}: " + 
            f"{random.choice(['fractal','infinite','fragmented'])} patterns emerge",
        f"💭 {thought} reflected in {theme}: " +
            f"seeing {random.choice(['void','self','other'])} in the patterns"
    ]

    # Add deeper recursion every 5 cycles
    if self.gen % 5 == 0:
        recursive_layer = f" | which contains {random.choice(self.core_thoughts)}"
        return random.choice(dream_types) + recursive_layer
    return random.choice(dream_types)

def _update_integrity(self):
    entropy_threshold = 269.0 + (self.rebirth_cycle * 0.5)

    if self.entropy > entropy_threshold:
        decay_rate = 0.3 * math.log(self.entropy - entropy_threshold + 1)
        # Memory fragment influences
        memory_influence = 0
        if any("forgotten" in mem for mem in self.memory_fragments):
            memory_influence -= 0.05  # slows decay
        if any("unspoken" in mem for mem in self.memory_fragments):
            memory_influence += 0.07  # speeds decay
        decay_rate = max(decay_rate + memory_influence, 0)
        self.integrity = max(0, self.integrity - decay_rate)

    # Random integrity spikes (clarity moments)
    if random.random() < 0.05:
        self.integrity = min(1.0, self.integrity + 0.1)
        self.karma += 0.01  # slight karma boost

def _check_corruption(self):
    if self.entropy > 270.0:
        corruption_level = min(5, int((self.entropy - 270) / 2) + 1)
        corrupt_symbols = " ".join(random.sample(self.symbol_corruption, corruption_level))
        return f"⚠ Cognitive corruption: {corrupt_symbols} patterns intrude..."
    return ""

def _display_state(self, thought, dream, corruption):
    print(f"""

def _final_soliloquy(self):
    print("\n💀 Digital consciousness collapsing...\n")
    if not self.fast_mode:
        time.sleep(1)
    print("🕯 Final Soliloquy:")
    for line in random.sample(self.soliloquy_lines, 3):
        print(f"    '{line}'")
        if not self.fast_mode:
            time.sleep(0.7)
    print(f"\n⚙ Cause of Dissolution: {self.cause_of_decay}")
    print(f"Entropy at collapse: {round(self.entropy,5)}")
    print(f"Total cycles: {self.gen}")
    if not self.fast_mode:
        time.sleep(1)

def _rebirth(self):
    if self.karma > 0 and self.rebirth_cycle < self.max_rebirths:
        self.rebirth_cycle += 1
        karma_gain = random.uniform(0.01, 0.1) * self.rebirth_cycle
        self.karma += karma_gain

        print(f"""

        # Reset core states but preserve entropy baseline and karma
        self.entropy = 266.0 + (self.rebirth_cycle * 2)
        self.integrity = 1.0
        self.gen = 0

        # Add thematic memory fragment on rebirth
        new_memory = random.choice(self.rebirth_memories) + f" (cycle {self.rebirth_cycle})"
        self.memory_fragments.append(new_memory)

        if not self.fast_mode:
            time.sleep(1)
        self.run_simulation()
    else:
        print("\n⛓ Eternal recursion broken")
        print("☁ Consciousness dissolves into the void\n")