fix: readme typo, poor rng handling, small tweaks

Signed-off-by: hashcatHitman <155700084+hashcatHitman@users.noreply.github.com>

Author: hashcatHitman

README.md

@@ -16,7 +16,7 @@ SPDX-License-Identifier: Apache-2.0 OR MIT
 
 #### Botania
 
-_Botania_ is a tech mod for _Minecraft_ created by Vazkii,with a focus on
+_Botania_ is a tech mod for _Minecraft_ created by Vazkii, with a focus on
 "natural magic". The primary resource in the mod is "mana", which is primarily
 obtained by means of specially crafted "generating flora". Some are trivial,
 such as "Hydroangeas", which consume nearby water and slowly produce mana.

src/bees.rs

@@ -17,7 +17,7 @@
 //!              2 flower_patch[i] = Site_abandonment(flower_patch[i])
 //!              3 flower_patch[i] = Neighbourhood_shrinking(flower_patch[i])
 //!        iii for i = nb, ..., ns
-//!              1 flower_patch[i] = Global_search(flower_patch[i])}
+//!              1 flower_patch[i] = Global_search(flower_patch[i])
 //! ```
 
 use core::array;
@@ -95,10 +95,11 @@ where
 
     /// Explore random nearby [`Colony::Flower`]s based on the radius size. The
     /// current best is also provided for consideration.
-    fn explore(
+    fn explore<R: Rng>(
         origin: &Self::Flower,
         current_best: &Scout<N_SCOUTS, Self>,
         radius: usize,
+        rng: &mut R,
     ) -> Self::Flower;
 
     /// Return `true` when it is time to stop searching. Use the implementor of
@@ -174,7 +175,7 @@ where
                 reason = "index is correct if invariants are upheld"
             )]
             for i in 0..Self::BEST_SITES {
-                flower_patches[i].local_search(&current_best);
+                flower_patches[i].local_search(&current_best, rng);
                 flower_patches[i].abandonment(&mut current_best, rng);
                 flower_patches[i].shrinking();
             }
@@ -287,13 +288,18 @@ where
     }
 
     /// Have the foragers explore nearby [`Colony::Flower`]s.
-    pub(crate) fn local_search(&mut self, current_best: &Scout<NS, Hive>) {
+    pub(crate) fn local_search<R: Rng>(
+        &mut self,
+        current_best: &Scout<NS, Hive>,
+        rng: &mut R,
+    ) {
         self.stagnation = true;
         for _ in 0..self.foragers {
             let new_solution = Hive::explore(
                 &self.scout.solution,
                 current_best,
                 self.neighbourhood,
+                rng,
             );
             let new_scout: Scout<NS, Hive> = Scout::with_solution(new_solution);
             if new_scout.fitness < self.scout.fitness {
@@ -327,6 +333,11 @@ where
             } else {
                 if self.scout.fitness < current_best.fitness {
                     *current_best = self.scout;
+                    // Just in case...
+                    println!(
+                        "New best during abandonment:\n\tFitness:{}\n\tSolution:\n{}",
+                        current_best.fitness, current_best.solution
+                    );
                 }
                 *self = Self::new(rng);
             }

src/lib.rs

@@ -8,9 +8,8 @@
 use core::cmp::Ordering;
 use core::fmt::{Display, Formatter, Result};
 
-use rand::rngs::SmallRng;
+use rand::Rng;
 use rand::seq::SliceRandom as _;
-use rand::{Rng as _, SeedableRng as _};
 
 use crate::bees::{Colony, Scout};
 use crate::simulation::PetriDish;
@@ -105,28 +104,24 @@ impl Colony<60> for Hive {
         }
     }
 
-    fn explore(
+    fn explore<R: Rng>(
         origin: &Self::Flower,
         current_best: &Scout<60, Self>,
         radius: usize,
+        rng: &mut R,
     ) -> Self::Flower {
-        let mut rng = SmallRng::seed_from_u64(42);
         if radius == (25 * 25) {
             let new: Self::Flower = rng.random();
             return new;
         }
-        let mut base: Self::Flower = *origin;
-
-        if radius <= Self::MINIMUM_RADIUS {
-            if rng.random_bool(0.5) {
-                base = Self::Flower::OPTIMAL_100_ROUND;
-            } else {
-                base = current_best.solution();
-            }
-        }
+        let mut base: Self::Flower = if radius <= Self::MINIMUM_RADIUS {
+            current_best.solution()
+        } else {
+            *origin
+        };
         let mut coords: [(u8, u8); 624] = Self::Flower::NONCENTER_COORDS;
 
-        coords.shuffle(&mut rng);
+        coords.shuffle(rng);
 
         for (x, y) in coords.into_iter().take(radius) {
             let value: u8 = rng.random_range(0..3);
@@ -136,13 +131,7 @@ impl Colony<60> for Hive {
     }
 
     fn stopping_condition(&mut self) -> bool {
-        if self.iters < 5000_usize {
-            self.iters = self.iters.saturating_add(1);
-            false
-        } else {
-            true
-        }
-        // self.iters += 1;
-        // false
+        // Just keep going.
+        false
     }
 }

src/simulation.rs

@@ -48,6 +48,10 @@ impl PetriDish {
     /// algorithm in 2016.
     ///
     /// [the setup found by Cobra1117]: https://www.reddit.com/r/botania/comments/5by0jl/optimal_100round_dandelifeon_setup/
+    #[expect(
+        dead_code,
+        reason = "Didn't want to use this when generating solutions to present."
+    )]
     pub(crate) const OPTIMAL_100_ROUND: Self = {
         let mut current_record: Self = Self::new();