Update app.py

app.py

@@ -7,7 +7,12 @@ import time
 
 class Organelle:
     def __init__(self, type):
-        self.type = type  # e.g., "nucleus", "mitochondria", "chloroplast"
+        self.type = type
+
+class Modification:
+    def __init__(self, name, effect):
+        self.name = name
+        self.effect = effect
 
 class Cell:
     def __init__(self, x, y, cell_type="prokaryote"):
@@ -16,21 +21,23 @@ class Cell:
         self.energy = 100
         self.cell_type = cell_type
         self.organelles = []
+        self.modifications = []
         self.size = 1
-        self.color = "blue"
+        self.color = "lightblue"
         self.division_threshold = 150
         
-        if cell_type == "prokaryote":
-            self.color = "lightblue"
-        elif cell_type == "early_eukaryote":
+        self.update_properties()
+
+    def update_properties(self):
+        if self.cell_type == "early_eukaryote":
             self.organelles.append(Organelle("nucleus"))
             self.color = "green"
             self.size = 2
-        elif cell_type == "advanced_eukaryote":
+        elif self.cell_type == "advanced_eukaryote":
             self.organelles.extend([Organelle("nucleus"), Organelle("mitochondria")])
             self.color = "red"
             self.size = 3
-        elif cell_type == "plant_like":
+        elif self.cell_type == "plant_like":
             self.organelles.extend([Organelle("nucleus"), Organelle("mitochondria"), Organelle("chloroplast")])
             self.color = "darkgreen"
             self.size = 4
@@ -43,13 +50,15 @@ class Cell:
         self.energy -= 0.5 * self.size
 
     def feed(self, environment):
+        base_energy = environment.grid[int(self.y)][int(self.x)] * 0.1
         if "chloroplast" in [org.type for org in self.organelles]:
-            # Photosynthesis
-            self.energy += environment.light_level * 2
-        else:
-            # Consume environmental nutrients
-            self.energy += environment.grid[int(self.y)][int(self.x)] * 0.1
-            environment.grid[int(self.y)][int(self.x)] *= 0.9
+            base_energy += environment.light_level * 2
+        
+        for mod in self.modifications:
+            base_energy *= mod.effect
+
+        self.energy += base_energy
+        environment.grid[int(self.y)][int(self.x)] *= 0.9
 
     def can_divide(self):
         return self.energy > self.division_threshold
@@ -57,35 +66,57 @@ class Cell:
     def divide(self):
         if self.can_divide():
             self.energy /= 2
-            return Cell(self.x, self.y, self.cell_type)
+            new_cell = Cell(self.x, self.y, self.cell_type)
+            new_cell.organelles = self.organelles.copy()
+            new_cell.modifications = self.modifications.copy()
+            return new_cell
         return None
 
     def can_fuse(self, other):
-        return (self.cell_type == "prokaryote" and other.cell_type == "prokaryote" and
-                random.random() < 0.001)  # 0.1% chance of fusion
+        return (self.cell_type == other.cell_type and
+                random.random() < 0.005)  # 0.5% chance of fusion
 
     def fuse(self, other):
+        new_cell_type = self.cell_type
+        if self.cell_type == "prokaryote":
+            new_cell_type = "early_eukaryote"
+        elif self.cell_type == "early_eukaryote":
+            new_cell_type = "advanced_eukaryote"
+
         new_cell = Cell(
             (self.x + other.x) / 2,
             (self.y + other.y) / 2,
-            "early_eukaryote"
+            new_cell_type
         )
         new_cell.energy = self.energy + other.energy
+        new_cell.organelles = list(set(self.organelles + other.organelles))
+        new_cell.modifications = list(set(self.modifications + other.modifications))
+        new_cell.update_properties()
         return new_cell
 
+    def acquire_modification(self):
+        possible_mods = [
+            Modification("Enhanced metabolism", 1.2),
+            Modification("Thick cell wall", 0.8),
+            Modification("Efficient energy storage", 1.1),
+            Modification("Rapid division", 0.9)
+        ]
+        new_mod = random.choice(possible_mods)
+        if new_mod not in self.modifications:
+            self.modifications.append(new_mod)
+            self.color = "purple"  # Visual indicator of modification
+
 class Environment:
     def __init__(self, width, height):
         self.width = width
         self.height = height
-        self.grid = np.random.rand(height, width) * 10  # Nutrient distribution
-        self.light_level = 5  # Ambient light level
+        self.grid = np.random.rand(height, width) * 10
+        self.light_level = 5
         self.cells = []
         self.time = 0
         self.population_history = {
-            "prokaryote": [],
-            "early_eukaryote": [],
-            "advanced_eukaryote": [],
-            "plant_like": []
+            "prokaryote": [], "early_eukaryote": [],
+            "advanced_eukaryote": [], "plant_like": [], "modified": []
         }
 
     def add_cell(self, cell):
@@ -93,10 +124,8 @@ class Environment:
 
     def update(self):
         self.time += 1
-        
-        # Update environment
         self.grid += np.random.rand(self.height, self.width) * 0.1
-        self.light_level = 5 + np.sin(self.time / 100) * 2  # Fluctuating light levels
+        self.light_level = 5 + np.sin(self.time / 100) * 2
 
         new_cells = []
         cells_to_remove = []
@@ -124,23 +153,24 @@ class Environment:
         self.cells.extend(new_cells)
         self.cells = [cell for cell in self.cells if cell not in cells_to_remove]
 
-        # Introduce mutations
+        # Introduce mutations and modifications
         for cell in self.cells:
             if random.random() < 0.0001:  # 0.01% chance of mutation
                 if cell.cell_type == "early_eukaryote":
                     cell.cell_type = "advanced_eukaryote"
-                    cell.organelles.append(Organelle("mitochondria"))
-                    cell.color = "red"
-                    cell.size = 3
                 elif cell.cell_type == "advanced_eukaryote" and random.random() < 0.5:
                     cell.cell_type = "plant_like"
-                    cell.organelles.append(Organelle("chloroplast"))
-                    cell.color = "darkgreen"
-                    cell.size = 4
+                cell.update_properties()
+            
+            if random.random() < 0.0005:  # 0.05% chance of acquiring a modification
+                cell.acquire_modification()
 
         # Record population counts
         for cell_type in self.population_history.keys():
-            count = len([cell for cell in self.cells if cell.cell_type == cell_type])
+            if cell_type != "modified":
+                count = len([cell for cell in self.cells if cell.cell_type == cell_type and not cell.modifications])
+            else:
+                count = len([cell for cell in self.cells if cell.modifications])
             self.population_history[cell_type].append(count)
 
     def get_visualization_data(self):
@@ -148,13 +178,15 @@ class Environment:
             "prokaryote": {"x": [], "y": [], "size": [], "color": "lightblue"},
             "early_eukaryote": {"x": [], "y": [], "size": [], "color": "green"},
             "advanced_eukaryote": {"x": [], "y": [], "size": [], "color": "red"},
-            "plant_like": {"x": [], "y": [], "size": [], "color": "darkgreen"}
+            "plant_like": {"x": [], "y": [], "size": [], "color": "darkgreen"},
+            "modified": {"x": [], "y": [], "size": [], "color": "purple"}
         }
 
         for cell in self.cells:
-            cell_data[cell.cell_type]["x"].append(cell.x)
-            cell_data[cell.cell_type]["y"].append(cell.y)
-            cell_data[cell.cell_type]["size"].append(cell.size * 3)
+            cell_type = "modified" if cell.modifications else cell.cell_type
+            cell_data[cell_type]["x"].append(cell.x)
+            cell_data[cell_type]["y"].append(cell.y)
+            cell_data[cell_type]["size"].append(cell.size * 3)
 
         return cell_data, self.population_history
 
@@ -178,16 +210,16 @@ def setup_figure(env):
     fig.update_xaxes(title_text="Time", row=1, col=2)
     fig.update_yaxes(title_text="Population", row=1, col=2)
 
-    fig.update_layout(height=600, width=1200, title_text="Cell Evolution Simulation")
+    fig.update_layout(height=600, width=1200, title_text="Advanced Cell Evolution Simulation")
 
     return fig
 
 # Streamlit app
-st.title("Cell Evolution Simulation")
+st.title("Advanced Cell Evolution Simulation")
 
-num_steps = st.slider("Number of simulation steps", 100, 1000, 500)
-initial_cells = st.slider("Initial number of cells", 10, 100, 50)
-update_interval = st.slider("Update interval (milliseconds)", 100, 1000, 200)
+num_steps = st.slider("Number of simulation steps", 100, 2000, 1000)
+initial_cells = st.slider("Initial number of cells", 10, 200, 100)
+update_interval = st.slider("Update interval (milliseconds)", 50, 500, 100)
 
 if st.button("Run Simulation"):
     env = Environment(100, 100)
@@ -214,9 +246,9 @@ if st.button("Run Simulation"):
                 fig.data[i].marker.size = data["size"]
             
             for i, (cell_type, counts) in enumerate(population_history.items()):
-                fig.data[i+4].y = counts  # +4 because we have 4 cell types in the first subplot
+                fig.data[i+5].y = counts  # +5 because we have 5 cell types in the first subplot
         
-        fig.layout.title.text = f"Cell Evolution Simulation (Time: {env.time})"
+        fig.layout.title.text = f"Advanced Cell Evolution Simulation (Time: {env.time})"
         
         # Update the chart
         chart.plotly_chart(fig, use_container_width=True)