slowly documenting, de-obfuscating, and ultimately trying to decipher this code after like 2 months away

Author: Liam-Wirth

Cargo.lock

@@ -17,6 +17,7 @@ instant = { version = "0.1.12", features = ["wasm-bindgen", "inaccurate"] }
 rand = "0.8.5"
 getrandom = { version = "0.2.12", features = ["js"] }
 ttf-parser = "0.20.0"
+web-sys = "0.3.69"
 
 # native:
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

Cargo.toml

@@ -1,11 +1,25 @@
+use crate::consts::*;
 use crate::conway;
 use crate::RunModes;
 use crate::UserInterface;
+use crate::Viewport;
 use conway::conway_map;
 use eframe::egui;
 use egui::Id;
+use web_sys::console;
+
+
+#[derive(Default)]
+pub struct MouseState {
+    pub is_dragging: bool,
+    pub last_pos: Option<egui::Pos2>,
+}
+
+
+
 use egui::LayerId;
 /// We derive Deserialize/Serialize so we can persist app state on shutdown.
+
 #[derive(serde::Deserialize, serde::Serialize)]
 #[serde(default)] // if we add new fields, give them default values when deserializing old state
 pub struct ConwaySim {
@@ -24,7 +38,10 @@ pub struct ConwaySim {
     view_stats: bool,
     first_run: bool,
     mode: RunModes,
+    #[serde(skip)] // This how you opt-out of serialization of a field
+    viewport:Viewport,
 }
+
 // TODO: implement feature so that the user can click and drag on the main view window to move
 // their view around instead of using sliders, cause sliders are janky as fuck
 
@@ -46,10 +63,12 @@ impl Default for ConwaySim {
             reset: false,
             first_run: true,
             mode: RunModes::default(),
+            viewport: Viewport::default(),
         }
     }
 }
 
+
 impl ConwaySim {
     /// Called once before the first frame.
     pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
@@ -63,9 +82,20 @@ impl ConwaySim {
 
         Default::default()
     }
+    fn handle_mouse_events(&mut self, ctx: &egui::Context) {
+
+
+    }
+
+    fn handle_scroll(&mut self, ctx: &egui::Context, scroll_delta: egui::Vec2) {
+         
+    }
 
     fn update_simulation(&mut self, ctx: &egui::Context) {
         egui::CentralPanel::default().show(ctx, |ui| {
+            let viewport_rect = ui.available_rect_before_wrap();
+            self.viewport.rect = viewport_rect;
+
             let gridline_layer: egui::LayerId =
                 LayerId::new(egui::Order::Foreground, Id::from("gridlines"));
             let painter = egui::Painter::new(
@@ -79,8 +109,9 @@ impl ConwaySim {
                 ui.available_rect_before_wrap(),
             );
             ui.expand_to_include_rect(painter.clip_rect());
-            ui.expand_to_include_rect(line_painter.clip_rect());
+            //ui.expand_to_include_rect(line_painter.clip_rect());
             self.rect = Some(painter.clip_rect());
+            //Logic that actually draws the screen I think
             let mut shapes: Vec<egui::Shape> = if self.map.light_mode {
                 vec![egui::Shape::rect_filled(
                     self.rect.unwrap(),
@@ -105,6 +136,12 @@ impl ConwaySim {
                 line_painter.extend(lines);
             }
         });
+            if ctx.input(|i| i.pointer.secondary_clicked() && i.pointer.is_decidedly_dragging()) {
+                println!("Dragging and such");
+                use crate::app::console;
+                console::log_1(&"erm, what the deuce".into());
+
+            }
 
         if self.view_stats {
             egui::Window::new("Stats").show(ctx, |ui| {
@@ -117,7 +154,7 @@ impl UserInterface for ConwaySim {
     fn update_side_panel(&mut self, ctx: &egui::Context) {
         egui::SidePanel::left("Menu").show(ctx, |ui| {
             ui.add(
-                egui::Slider::new(&mut self.map.cell_size, 0.1..=50.0)
+                egui::Slider::new(&mut self.map.cell_size, CELL_MIN..=CELL_MAX)
                     .step_by(0.1)
                     .orientation(egui::SliderOrientation::Horizontal)
                     .text("Cell Size"),
@@ -139,18 +176,18 @@ impl UserInterface for ConwaySim {
             // BUG: below sliders are bugged, if one of the viewports is updated, say, the x axis, the vertical
             // lines will not move along with the horizontal ones, leading to a realy weird effect, and vice
             // versa for the y axis, with the other lines not moving, while the vertical ones will move
-            // ui.add(
-            //     egui::Slider::new(&mut self.map.x_axis, -1000..=1000)
-            //         .step_by(1.0)
-            //         .orientation(egui::SliderOrientation::Horizontal)
-            //         .text("X Axis"),
-            // );
-            // ui.add(
-            //     egui::Slider::new(&mut self.map.y_axis, -1000..=1000)
-            //         .step_by(1.0)
-            //         .orientation(egui::SliderOrientation::Horizontal)
-            //         .text("Y Axis"),
-            // );
+             ui.add(
+                 egui::Slider::new(&mut self.map.x_axis, -1000..=1000)
+                     .step_by(1.0)
+                     .orientation(egui::SliderOrientation::Horizontal)
+                     .text("X Axis"),
+             );
+             ui.add(
+                 egui::Slider::new(&mut self.map.y_axis, -1000..=1000)
+                     .step_by(1.0)
+                     .orientation(egui::SliderOrientation::Horizontal)
+                     .text("Y Axis"),
+             );
             ui.add(
                 egui::Slider::new(&mut self.map.map_size, 10..=500)
                     .step_by(1.0)

src/app.rs

@@ -37,15 +37,25 @@ const NEIGHBORS: [(i32, i32); 8] = [
 
 #[derive(serde::Deserialize, serde::Serialize)]
 #[serde(default)] // if we add new fields, give them default values when deserializing old state
+/// Eventually will be generalized to be a "Map" struct, but for now it's just a Conway's Game of
 pub struct Map {
-    pub x_axis: i32,
-    pub y_axis: i32,
-    pub cell_size: f32,
+/// X axis of the map
+    pub x_axis: i32, 
+/// Y axis of the map
+    pub y_axis: i32, 
+/// Size of each cell in the map, will be clamped between constants CELL_MIN and CELL_MAX
+    pub cell_size: f32, 
+/// Size of the map, eventually I want this to be separate from our viewport
     pub map_size: i32,
+/// Speed of the simulation, in what unit? only God knows
     pub speed: u128,
+/// Frames per second
     pub fps: u32,
+///Determines the scarcity of cells in the initial state
     pub rand_scarcity: u32,
+/// Self explanatory
     pub light_mode: bool,
+/// Whether or not to draw gridlines
     pub lines: bool,
     pub is_initial: bool,
 
@@ -133,6 +143,7 @@ impl Map {
         self.cells = HashSet::new();
     }
     pub fn fps_to_speed(fps: f32) -> u128 {
+        //magic number?
         Duration::new(0, (1000000000.0 / fps) as u32).as_millis()
     }
     // NOTE: This could probably be useful for the refactor
@@ -196,6 +207,7 @@ impl Map {
         }
         (max_x, max_y)
     }
+    //What does this do????
     pub fn center_cells(&mut self, rect: Rect) {
         let (min_x, min_y) = self.find_min();
         let (max_x, max_y) = self.find_max();
@@ -214,9 +226,11 @@ impl Map {
 
         self.cells = elems_c;
     }
+    // TODO: Refactor this code to actually work based on viewport logic instead, this might help
+    // fix that bug I'm having regarding the x and y values not moving along when we update them
     pub fn draw_lines(&mut self, rect: Rect, shapes: &mut Vec<Shape>) {
         // Calculate stroke thickness based on cell size
-        let stroke_thickness = self.exponential_easing(0.1, 50.0, 0.0, 2.0);
+        let stroke_thickness = self.exponential_easing(crate::CELL_MIN, crate::CELL_MAX, 0.0, 2.0);
 
         // Draw vertical grid lines
         for i in 0..=self.map_size {
@@ -289,6 +303,7 @@ impl Map {
         let exponent = -k * (self.cell_size - x_0);
         1.0 / (1.0 + exponent.exp())
     }
+    /// Another easing function but this time we use exponential stuff cause I can
     fn exponential_easing(
         &mut self,
         min_cell_size: f32,

src/conway/conway_map.rs

@@ -3,6 +3,8 @@ pub mod app;
 pub mod conway;
 pub use app::ConwaySim;
 pub use conway::conway_map::Map;
+pub use consts::*;
+use web_sys::console;
 
 #[derive(Default)]
 pub struct RunStatistics {
@@ -21,6 +23,23 @@ impl RunStatistics {
         }
     }
 }
+/// DECLARATION OF CONSTS
+
+pub mod consts {
+pub const ZOOM_SENSITIVITY: f32 = 0.1;
+
+pub const CELL_MAX: f32 = 50.0;
+pub const CELL_MIN: f32 = 0.1;
+}
+
+
+
+
+
+
+
+
+
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, serde::Deserialize, serde::Serialize)]
 #[serde(default)] // if we add new fields, give them default values when deserializing old state
 #[derive(Default)]
@@ -40,3 +59,19 @@ pub trait UserInterface {
     fn update_menu_bar(&self, ctx: &egui::Context);
     fn update_side_panel(&mut self, ctx: &egui::Context);
 }
+
+pub struct Viewport {
+    pub rect: egui::Rect,
+    pub scale: f32, // Scale factor for zooming
+    pub offset: egui::Vec2, // Offset for panning
+}
+
+impl Default for Viewport {
+    fn default() -> Self {
+        Self {
+            rect: egui::Rect::from_min_size(egui::Pos2::ZERO, egui::Vec2::ZERO),
+            scale: 1.0,
+            offset: egui::Vec2::default(),
+        }
+    }
+}

src/lib.rs

@@ -1,5 +1,6 @@
 #![warn(clippy::all, rust_2018_idioms)]
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+use web_sys::console;
 
 // When compiling natively:
 #[cfg(not(target_arch = "wasm32"))]
@@ -29,6 +30,7 @@ fn main() -> eframe::Result<()> {
 fn main() {
     // Redirect `log` message to `console.log` and friends:
     eframe::WebLogger::init(log::LevelFilter::Debug).ok();
+    console::log_1(&"erm, what the deuce".into());
     let the_canvas_id = String::from("Cellular-Automata beta 0.0.1");
     let web_options = eframe::WebOptions::default();
     wasm_bindgen_futures::spawn_local(async {