Merge pull request #1 from jo56/fixing-cleanup

Adding additional patterns and post-test release fixes

Author: jo56

.claude/settings.local.json

@@ -3,7 +3,14 @@
     "allow": [
       "WebFetch(domain:github.com)",
       "Bash(cargo build:*)",
-      "Bash(tree:*)"
+      "Bash(tree:*)",
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "Bash(cargo check:*)",
+      "Bash(cargo run:*)",
+      "Bash(RUST_BACKTRACE=1 cargo run)",
+      "Bash(set RUST_BACKTRACE=1)",
+      "Bash(timeout:*)",
+      "Bash(cargo fix:*)"
     ],
     "deny": [],
     "ask": []

sim-app/src/main.rs

@@ -1,3 +1,6 @@
+// Hide console window on Windows in release builds
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
 mod viewer_2d;
 mod viewer_3d;
 
@@ -8,6 +11,7 @@ fn main() -> eframe::Result {
     let options = eframe::NativeOptions {
         viewport: egui::ViewportBuilder::default()
             .with_inner_size([1280.0, 800.0])
+            .with_position([200.0, 50.0])
             .with_title("Complex Systems Visualizer"),
         ..Default::default()
     };
@@ -42,9 +46,15 @@ impl ComplexSystemsApp {
             Box::new(julia::Julia::new()),
             Box::new(burning_ship::BurningShip::new()),
 
-            // Cellular Systems
+            // Cellular Systems & Emergent Complexity
             Box::new(game_of_life::GameOfLife::new()),
             Box::new(cellular_automaton::CellularAutomaton::new(30)),
+            Box::new(langtons_ant::LangtonsAnt::new()),
+            Box::new(cyclic_ca::CyclicCA::new()),
+
+            // Growth & Self-Organization
+            Box::new(dla::DLA::new()),
+            Box::new(sandpile::Sandpile::new()),
 
             // Animated Simulations
             Box::new(double_pendulum::DoublePendulum::new()),
@@ -59,9 +69,22 @@ impl ComplexSystemsApp {
             Box::new(generative::Boids::new()),
             Box::new(generative::DeJongAttractor::new()),
             Box::new(generative::CliffordAttractor::new()),
+
+            // Complex Emergent Simulations
+            Box::new(slime_mold::SlimeMold::new()),
+            Box::new(falling_sand::FallingSand::new()),
         ];
 
         let simulations_3d: Vec<Simulation3DBox> = vec![
+            // Stunning 3D Visualizations
+            Box::new(dna_helix::DNAHelix::new()),
+            Box::new(torus_knot::TorusKnot::new()),
+            Box::new(galaxy_spiral::GalaxySpiral::new()),
+
+            // Enhanced Particle Systems
+            Box::new(particle_attractor_3d::ParticleAttractor3D::new()),
+            Box::new(boids_3d::Boids3D::new()),
+
             // Classic Attractors
             Box::new(lorenz::LorenzAttractor::new()),
             Box::new(rossler::RosslerAttractor::new()),
@@ -72,6 +95,16 @@ impl ComplexSystemsApp {
             Box::new(dadras::DadrasAttractor::new()),
             Box::new(thomas::ThomasAttractor::new()),
             Box::new(chen::ChenAttractor::new()),
+
+            // Diverse Particle Simulations
+            Box::new(nbody_gravity::NBodyGravity::new()),
+            Box::new(fluid_sph::FluidSPH::new()),
+            Box::new(magnetic_field::MagneticField::new()),
+
+            // Radical 3D Animations
+            Box::new(vortex_turbulence::VortexTurbulence::new()),
+            Box::new(lightning_bolt::LightningBolt::new()),
+            Box::new(fractal_tree_3d::FractalTree3D::new()),
         ];
 
         Self {
@@ -112,6 +145,45 @@ impl eframe::App for ComplexSystemsApp {
 
                 ui.separator();
 
+                // Global scale/zoom controls
+                match self.sim_type {
+                    SimulationType::TwoD => {
+                        ui.horizontal(|ui| {
+                            ui.label("🔍 Pattern Detail:");
+                            if ui.add(egui::Slider::new(&mut self.viewer_2d.scale, 0.25..=2.0)
+                                .text("Scale")).changed() {
+                                self.viewer_2d.needs_update = true;
+                                // Reset pan when scale changes to prevent shift
+                                self.viewer_2d.pan_x = 0.0;
+                                self.viewer_2d.pan_y = 0.0;
+                            }
+                            if ui.button("Reset Scale").clicked() {
+                                self.viewer_2d.scale = 1.0;
+                                self.viewer_2d.needs_update = true;
+                                self.viewer_2d.pan_x = 0.0;
+                                self.viewer_2d.pan_y = 0.0;
+                            }
+                            if ui.button("Reset Pan").clicked() {
+                                self.viewer_2d.pan_x = 0.0;
+                                self.viewer_2d.pan_y = 0.0;
+                            }
+                        });
+                        ui.label(format!("📐 Resolution: {}x{} pixels",
+                            (800.0 * self.viewer_2d.scale) as i32,
+                            (600.0 * self.viewer_2d.scale) as i32));
+                        ui.label("💡 Tip: Drag to pan when zoomed");
+                    }
+                    SimulationType::ThreeD => {
+                        ui.horizontal(|ui| {
+                            ui.label("🔍 View Zoom:");
+                            ui.add(egui::Slider::new(&mut self.viewer_3d.zoom, 0.5..=5.0)
+                                .text("Zoom"));
+                        });
+                    }
+                }
+
+                ui.separator();
+
                 egui::ScrollArea::vertical().show(ui, |ui| {
 
                     match self.sim_type {
@@ -162,7 +234,7 @@ impl eframe::App for ComplexSystemsApp {
         egui::CentralPanel::default().show(ctx, |ui| {
             match self.sim_type {
                 SimulationType::TwoD => {
-                    self.viewer_2d.show(ui, &self.simulations_2d[self.sim_2d_index]);
+                    self.viewer_2d.show(ui, &mut self.simulations_2d[self.sim_2d_index]);
                 }
                 SimulationType::ThreeD => {
                     let dt = ui.input(|i| i.stable_dt);

sim-app/src/viewer_2d.rs

@@ -3,6 +3,9 @@ use sim_core::Simulation2D;
 
 pub struct Viewer2D {
     pub needs_update: bool,
+    pub scale: f32,
+    pub pan_x: f32,
+    pub pan_y: f32,
     texture: Option<egui::TextureHandle>,
     width: usize,
     height: usize,
@@ -12,16 +15,19 @@ impl Viewer2D {
     pub fn new() -> Self {
         Self {
             needs_update: true,
+            scale: 1.0,
+            pan_x: 0.0,
+            pan_y: 0.0,
             texture: None,
             width: 800,
             height: 600,
         }
     }
 
-    pub fn show(&mut self, ui: &mut egui::Ui, simulation: &Box<dyn Simulation2D>) {
+    pub fn show(&mut self, ui: &mut egui::Ui, simulation: &mut Box<dyn Simulation2D>) {
         let available_size = ui.available_size();
-        let width = available_size.x as usize;
-        let height = available_size.y as usize;
+        let width = (available_size.x * self.scale) as usize;
+        let height = (available_size.y * self.scale) as usize;
 
         // Check if we need to recompute
         if self.needs_update || width != self.width || height != self.height {
@@ -56,10 +62,32 @@ impl Viewer2D {
             self.needs_update = false;
         }
 
-        // Display texture
+        // Create an interactive area for the image
         if let Some(texture) = &self.texture {
-            let size = egui::vec2(width as f32, height as f32);
-            ui.image((texture.id(), size));
+            let display_size = egui::vec2(available_size.x, available_size.y);
+
+            // Create a scrollable area if image is larger than display
+            let response = ui.allocate_rect(
+                egui::Rect::from_min_size(ui.cursor().min, display_size),
+                egui::Sense::click_and_drag(),
+            );
+
+            // Handle dragging for panning
+            if response.dragged() && simulation.supports_zoom() {
+                let delta = response.drag_delta();
+                // Adjust the simulation's center position
+                simulation.adjust_center(delta.x as f64, delta.y as f64, width, height);
+                self.needs_update = true;
+            }
+
+            // Draw the image
+            let rect = response.rect;
+            ui.painter().image(
+                texture.id(),
+                rect,
+                egui::Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0)),
+                egui::Color32::WHITE,
+            );
         }
     }
 }