Create app.py

app.py

@@ -0,0 +1,202 @@
+import random
+import numpy as np
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import streamlit as st
+
+class Organelle:
+    def __init__(self, type):
+        self.type = type  # e.g., "nucleus", "mitochondria", "chloroplast"
+
+class Cell:
+    def __init__(self, x, y, cell_type="prokaryote"):
+        self.x = x
+        self.y = y
+        self.energy = 100
+        self.cell_type = cell_type
+        self.organelles = []
+        self.size = 1
+        self.color = "blue"
+        self.division_threshold = 150
+        
+        if cell_type == "prokaryote":
+            self.color = "lightblue"
+        elif cell_type == "early_eukaryote":
+            self.organelles.append(Organelle("nucleus"))
+            self.color = "green"
+            self.size = 2
+        elif cell_type == "advanced_eukaryote":
+            self.organelles.extend([Organelle("nucleus"), Organelle("mitochondria")])
+            self.color = "red"
+            self.size = 3
+        elif cell_type == "plant_like":
+            self.organelles.extend([Organelle("nucleus"), Organelle("mitochondria"), Organelle("chloroplast")])
+            self.color = "darkgreen"
+            self.size = 4
+
+    def move(self, environment):
+        dx = random.uniform(-1, 1)
+        dy = random.uniform(-1, 1)
+        self.x = max(0, min(environment.width - 1, self.x + dx))
+        self.y = max(0, min(environment.height - 1, self.y + dy))
+        self.energy -= 0.5 * self.size
+
+    def feed(self, environment):
+        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
+
+    def can_divide(self):
+        return self.energy > self.division_threshold
+
+    def divide(self):
+        if self.can_divide():
+            self.energy /= 2
+            return Cell(self.x, self.y, self.cell_type)
+        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
+
+    def fuse(self, other):
+        new_cell = Cell(
+            (self.x + other.x) / 2,
+            (self.y + other.y) / 2,
+            "early_eukaryote"
+        )
+        new_cell.energy = self.energy + other.energy
+        return new_cell
+
+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.cells = []
+        self.time = 0
+
+    def add_cell(self, cell):
+        self.cells.append(cell)
+
+    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
+
+        new_cells = []
+        cells_to_remove = []
+
+        for cell in self.cells:
+            cell.move(self)
+            cell.feed(self)
+
+            if cell.energy <= 0:
+                cells_to_remove.append(cell)
+            elif cell.can_divide():
+                new_cell = cell.divide()
+                if new_cell:
+                    new_cells.append(new_cell)
+
+        # Handle cell fusion
+        for i, cell1 in enumerate(self.cells):
+            for cell2 in self.cells[i+1:]:
+                if cell1.can_fuse(cell2):
+                    new_cell = cell1.fuse(cell2)
+                    new_cells.append(new_cell)
+                    cells_to_remove.extend([cell1, cell2])
+
+        # Add new cells and remove dead/fused cells
+        self.cells.extend(new_cells)
+        self.cells = [cell for cell in self.cells if cell not in cells_to_remove]
+
+        # Introduce mutations
+        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
+
+    def visualize(self):
+        fig = make_subplots(rows=1, cols=2, subplot_titles=("Cell Distribution", "Population Over Time"))
+
+        # Cell distribution
+        cell_types = set(cell.cell_type for cell in self.cells)
+        for cell_type in cell_types:
+            x = [cell.x for cell in self.cells if cell.cell_type == cell_type]
+            y = [cell.y for cell in self.cells if cell.cell_type == cell_type]
+            color = next(cell.color for cell in self.cells if cell.cell_type == cell_type)
+            size = next(cell.size * 3 for cell in self.cells if cell.cell_type == cell_type)
+            fig.add_trace(go.Scatter(x=x, y=y, mode='markers', marker=dict(color=color, size=size),
+                                     name=cell_type), row=1, col=1)
+
+        fig.update_xaxes(title_text="X", row=1, col=1)
+        fig.update_yaxes(title_text="Y", row=1, col=1)
+
+        # Population over time
+        population_counts = {
+            "prokaryote": [],
+            "early_eukaryote": [],
+            "advanced_eukaryote": [],
+            "plant_like": []
+        }
+
+        for cell_type in population_counts:
+            count = len([cell for cell in self.cells if cell.cell_type == cell_type])
+            population_counts[cell_type].append(count)
+
+        for cell_type, counts in population_counts.items():
+            fig.add_trace(go.Scatter(y=counts, mode='lines', name=cell_type), row=1, col=2)
+
+        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=f"Cell Evolution Simulation (Time: {self.time})")
+        return fig
+
+def run_simulation(num_steps, initial_cells):
+    env = Environment(100, 100)
+    
+    # Add initial cells
+    for _ in range(initial_cells):
+        cell = Cell(random.uniform(0, env.width), random.uniform(0, env.height))
+        env.add_cell(cell)
+    
+    # Run simulation
+    for step in range(num_steps):
+        env.update()
+        if step % 10 == 0:  # Visualize every 10 steps
+            yield env.visualize()
+
+# Streamlit app
+st.title("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)
+
+if st.button("Run Simulation"):
+    simulation = run_simulation(num_steps, initial_cells)
+    
+    # Create a placeholder for the chart
+    chart_placeholder = st.empty()
+    
+    # Update the chart for each step
+    for chart in simulation:
+        chart_placeholder.plotly_chart(chart, use_container_width=True)
+
+    st.write("Simulation complete!")