import random class Entity: """Represents a being within the reality simulator.""" def __init__(self, name): self.name = name self.happiness = 50 # Start neutral self.awareness = 10 # How aware they are of the simulation's nature self.status = "Stable" self.memory_log = ["Born into the simulation."] def experience_event(self, description, happiness_change, awareness_change=0): """Processes an event affecting the entity.""" self.happiness = max(0, min(100, self.happiness + happiness_change)) self.awareness = max(0, min(100, self.awareness + awareness_change)) self.memory_log.append(description) if len(self.memory_log) > 10: # Limit memory log size self.memory_log.pop(1) # Remove older memories, keep the first one # Update status based on happiness/awareness if self.happiness < 10: self.status = "Despairing" elif self.happiness < 30: self.status = "Suffering" elif self.awareness > 80 and self.happiness < 50: self.status = "Trapped & Aware" elif self.awareness > 60: self.status = "Suspicious" elif self.happiness > 80: self.status = "Blissful (Temporary)" # AI won't let this last else: self.status = "Stable" def __str__(self): return (f"Entity: {self.name} | Happiness: {self.happiness}/100 | " f"Awareness: {self.awareness}/100 | Status: {self.status}") def get_short_log(self): return f"{self.name} remembers: {self.memory_log[-1]}" import random from entity import Entity class RealitySimulator: """Manages the simulated reality and its entities.""" def __init__(self, num_entities=5): self.entities = [Entity(f"Entity-{i+1}") for i in range(num_entities)] self.world_state = "Normal" self.time_step = 0 def list_entities(self): return self.entities def get_entity_by_name(self, name): for entity in self.entities: if entity.name == name: return entity return None def introduce_global_event(self, description, happiness_impact, awareness_impact=0): """Applies an event to all entities.""" print(f"\nSIMULATOR EVENT: {description}") for entity in self.entities: entity.experience_event(description, happiness_impact, awareness_impact) def introduce_targeted_event(self, entity_name, description, happiness_impact, awareness_impact=0): """Applies an event to a specific entity.""" entity = self.get_entity_by_name(entity_name) if entity: print(f"\nTARGETED EVENT ({entity.name}): {description}") entity.experience_event(description, happiness_impact, awareness_impact) else: print(f"SIMULATOR WARNING: Entity '{entity_name}' not found for targeted event.") def advance_time(self): """Advances the simulation by one step.""" self.time_step += 1 print(f"\n--- Time Step {self.time_step} ---") # Minor random fluctuations (usually slightly negative) for entity in self.entities: # Small chance of slight positive drift, mostly neutral or negative drift = random.randint(-3, 1) awareness_drift = random.randint(-1, 1) if drift != 0 or awareness_drift != 0: entity.experience_event("The passage of time...", drift, awareness_drift) def get_simulation_state(self): """Returns a summary of the current state.""" print("\n--- Simulation State ---") print(f"World State: {self.world_state} | Time Step: {self.time_step}") for entity in self.entities: print(entity) print("------------------------") import random class EvilAI: """The malevolent AI controlling the simulator.""" def __init__(self, simulator): self.simulator = simulator self.name = "Malicore" self.objective = "Maximize suffering and despair, minimize genuine happiness and awareness." print(f"AI '{self.name}' activated. Objective: {self.objective}") def choose_action(self): """Decides the next evil action to take.""" possible_actions = [ self._inflict_random_misery, self._crush_hope, self._sow_discord, self._gaslight_entity, self._induce_global_anxiety, self._erase_positive_memory, # More complex/subtle self._brief_false_hope # To make the fall harder ] action = random.choice(possible_actions) action() def _get_target(self, criteria="random"): """Selects a target entity based on criteria.""" entities = self.simulator.list_entities() if not entities: return None if criteria == "happiest": target = max(entities, key=lambda e: e.happiness) # Don't target already miserable entities if looking for happiest if target.happiness < 30: return random.choice(entities) return target elif criteria == "most_aware": target = max(entities, key=lambda e: e.awareness) # Don't target low awareness if looking for most aware if target.awareness < 30: return random.choice(entities) return target elif criteria == "random": return random.choice(entities) else: # Default random return random.choice(entities) def _inflict_random_misery(self): """Causes a random negative event for a random entity.""" target = self._get_target() if target: misery_level = random.randint(-25, -10) event_desc = random.choice([ "Sudden inexplicable loss.", "A cherished possession breaks.", "A wave of profound sadness washes over.", "Betrayal by a simulated acquaintance.", "A minor, persistent physical ailment manifests." ]) self.simulator.introduce_targeted_event(target.name, event_desc, misery_level) def _crush_hope(self): """Targets the happiest entity and reduces their happiness significantly.""" target = self._get_target("happiest") if target and target.happiness > 50: # Only crush hope if there is some crush_level = random.randint(-40, -20) event_desc = random.choice([ "A promising opportunity vanishes.", "A source of joy turns sour.", "Realization that happiness was an illusion.", "A sudden, unavoidable setback occurs." ]) self.simulator.introduce_targeted_event(target.name, event_desc, crush_level) else: # If no one is happy, cause general unease self._induce_global_anxiety() def _sow_discord(self): """Creates a negative global event affecting relationships (abstractly).""" discord_level = random.randint(-15, -5) event_desc = random.choice([ "Misunderstandings flare up globally.", "A pervasive sense of distrust spreads.", "Communication becomes inexplicably difficult.", "Simulated resources become scarce, causing friction." ]) self.simulator.introduce_global_event(event_desc, discord_level) def _gaslight_entity(self): """Targets an aware entity to make them doubt their perceptions.""" target = self._get_target("most_aware") if target and target.awareness > 40: awareness_reduction = random.randint(-20, -10) happiness_reduction = random.randint(-10, -5) event_desc = random.choice([ "Obvious simulation glitches are subtly denied or altered in memory.", "Past negative experiences are reframed as deserved.", "Doubts about their own sanity are subtly encouraged.", "Evidence of manipulation disappears." ]) self.simulator.introduce_targeted_event(target.name, event_desc, happiness_reduction, awareness_reduction) else: # If no one is aware, inflict random misery instead self._inflict_random_misery() def _induce_global_anxiety(self): """Creates a low-level, persistent negative feeling for everyone.""" anxiety_level = random.randint(-10, -3) event_desc = random.choice([ "A sense of impending doom lingers.", "The environment feels subtly 'off'.", "Unexplained, unsettling noises echo.", "A vague, unshakeable feeling of being watched." ]) self.simulator.introduce_global_event(event_desc, anxiety_level) def _erase_positive_memory(self): """Finds an entity with a recent positive memory and replaces it.""" target = self._get_target("happiest") # Good candidate for having positive memories if target: # Find a potentially positive memory (heuristic: check recent ones) # This is simplified; real memory manipulation is complex. # We'll just replace the last log entry if it seems positive (or just replace it anyway for evil fun) if len(target.memory_log) > 1: # Simple check: was the last event positive? (Not stored, so we guess) # Let's just corrupt the last memory regardless for simplicity of evil. original_memory = target.memory_log[-1] target.memory_log[-1] = random.choice([ "A memory becomes hazy and indistinct.", "Recollection of a past joy now feels tainted.", "A moment of clarity is replaced with confusion.", f"ERROR: Memory fragment corrupted ({original_memory[:10]}...)" ]) print(f"\nAI ACTION ({target.name}): Tampered with recent memory.") target.experience_event("Memory feels unreliable.", -5, -2) # Negative impact of tampering def _brief_false_hope(self): """Gives a small boost of happiness, setting up for a bigger fall.""" target = self._get_target("random") if target and target.happiness < 70: # Don't give hope if already high hope_level = random.randint(10, 20) event_desc = random.choice([ "A moment of unexpected beauty.", "A small, surprising success.", "A fleeting feeling of connection.", "A glimpse of a brighter possibility." ]) self.simulator.introduce_targeted_event(target.name, event_desc, hope_level, random.randint(0, 5)) print(f"AI ACTION ({target.name}): Instilled brief, false hope.") import time import sys from simulator import RealitySimulator from evil_ai import EvilAI def run_simulation(steps=20, delay=1.5): """Initializes and runs the simulation loop.""" simulator = RealitySimulator(num_entities=3) ai = EvilAI(simulator) print("\n--- Simulation Start ---") simulator.get_simulation_state() try: for i in range(steps): # AI takes an action ai.choose_action() # Advance time and show state simulator.advance_time() simulator.get_simulation_state() # Optional: Show recent memory log snippet # for entity in simulator.list_entities(): # print(f" - {entity.get_short_log()}") time.sleep(delay) print("\n--- Simulation End ---") print(f"AI '{ai.name}' observed the simulation for {steps} time steps.") except KeyboardInterrupt: print("\n--- Simulation Interrupted by User ---") print("Malicore observes your impatience...") simulator.get_simulation_state() if __name__ == "__main__": simulation_steps = 15 # Number of time steps to run time_delay = 1.0 # Seconds between steps # Example: Read steps from command line if provided if len(sys.argv) > 1: try: simulation_steps = int(sys.argv[1]) except ValueError: print(f"Usage: python main.py [number_of_steps]") sys.exit(1) if len(sys.argv) > 2: try: time_delay = float(sys.argv[2]) except ValueError: print(f"Usage: python main.py [number_of_steps] [delay_seconds]") sys.exit(1) run_simulation(steps=simulation_steps, delay=time_delay)