From d2c59a4d07efa3ec4418d7e82352a1cdf38e1518 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Fri, 19 Mar 2021 19:21:11 +0100
Subject: branch trying out bevy

---
 src/cell.rs | 143 ------------------------------------------------------------
 1 file changed, 143 deletions(-)
 delete mode 100644 src/cell.rs

(limited to 'src/cell.rs')

diff --git a/src/cell.rs b/src/cell.rs
deleted file mode 100644
index b085c5e..0000000
--- a/src/cell.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-use crate::constants;
-use ggez::graphics::{
-    self, spritebatch::SpriteBatch, Color, DrawMode, DrawParam, Mesh, Rect, StrokeOptions,
-};
-use ggez::mint::{Point2, Vector2};
-use ggez::{Context, GameResult};
-use rand::{
-    distributions::{Distribution, Standard},
-    Rng,
-};
-
-use std::time::Instant;
-#[derive(Clone, Copy, PartialEq)]
-pub enum Occupant {
-    None,
-    Green,
-    Yellow,
-    Diamond,
-    Red,
-    Explosion { frame: usize, timer: Instant },
-}
-
-impl Distribution<Occupant> for Standard {
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Occupant {
-        match rng.gen_range(0..=3) {
-            0 => Occupant::Green,
-            1 => Occupant::Yellow,
-            2 => Occupant::Diamond,
-            3 => Occupant::Red,
-            _ => Occupant::None,
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-pub struct Cell {
-    pub occupant: Occupant,
-    position: Point2<f32>,
-    hover: bool,
-    clicked: bool,
-}
-
-impl Cell {
-    pub fn new(position: Point2<f32>) -> Cell {
-        Cell {
-            occupant: rand::random(),
-            position,
-            hover: false,
-            clicked: false,
-        }
-    }
-
-    pub fn contains(&self, position: Point2<f32>) -> bool {
-        position.x > self.position.x
-            && position.y > self.position.y
-            && position.x < self.position.x + constants::TILE_WIDTH * constants::TILE_SCALE
-            && position.y < self.position.y + constants::TILE_WIDTH * constants::TILE_SCALE
-    }
-
-    pub fn moveable(&self) -> bool {
-        //!matches!(self.occupant, Occupant::Explosion{ ..} | Occupant::None)
-        match self.occupant {
-            Occupant::Explosion { .. } => false,
-            Occupant::None => false,
-            _ => true,
-        }
-    }
-
-    pub fn clicked_on(&mut self) {
-        self.clicked = true;
-    }
-
-    pub fn clicked_off(&mut self) {
-        self.clicked = false;
-    }
-
-    pub fn hover_on(&mut self) {
-        self.hover = true;
-    }
-
-    pub fn hover_off(&mut self) {
-        self.hover = false;
-    }
-
-    pub fn draw(&self, context: &mut Context, spritebatch: &mut SpriteBatch) -> GameResult {
-        let source = match self.occupant {
-            Occupant::None => None,
-            Occupant::Explosion { frame, .. } => match frame {
-                0 => Some(Rect::new(0.0, 0.5, 0.25, 0.5)),
-                1 => Some(Rect::new(0.25, 0.5, 0.25, 0.5)),
-                2 => Some(Rect::new(0.50, 0.5, 0.25, 0.5)),
-                3 => Some(Rect::new(0.75, 0.5, 0.25, 0.5)),
-                _ => None,
-            },
-            Occupant::Green => Some(Rect::new(0.0, 0.0, 0.25, 0.5)),
-            Occupant::Yellow => Some(Rect::new(0.25, 0.0, 0.25, 0.5)),
-            Occupant::Diamond => Some(Rect::new(0.50, 0.0, 0.25, 0.5)),
-            Occupant::Red => Some(Rect::new(0.75, 0.0, 0.25, 0.5)),
-        };
-
-        if let Some(source) = source {
-            spritebatch.add(
-                DrawParam::default()
-                    .src(source)
-                    .dest(self.position)
-                    .scale(Vector2 {
-                        x: constants::TILE_SCALE,
-                        y: constants::TILE_SCALE,
-                    }),
-            );
-        }
-
-        if self.hover {
-            let mesh = Mesh::new_rectangle(
-                context,
-                DrawMode::Stroke(StrokeOptions::default()),
-                Rect::new(
-                    self.position.x,
-                    self.position.y,
-                    constants::TILE_WIDTH * constants::TILE_SCALE,
-                    constants::TILE_HEIGHT * constants::TILE_SCALE,
-                ),
-                Color::from_rgb(255, 100, 100),
-            )?;
-            graphics::draw(context, &mesh, DrawParam::default())?;
-        }
-        if self.clicked {
-            let mesh = Mesh::new_rectangle(
-                context,
-                DrawMode::Stroke(StrokeOptions::default()),
-                Rect::new(
-                    self.position.x,
-                    self.position.y,
-                    constants::TILE_WIDTH * constants::TILE_SCALE,
-                    constants::TILE_HEIGHT * constants::TILE_SCALE,
-                ),
-                Color::from_rgb(100, 255, 100),
-            )?;
-            graphics::draw(context, &mesh, DrawParam::default())?;
-        }
-        Ok(())
-    }
-}
-- 
cgit v1.2.3


From 965ccb56c4c58066939d74bea22c2a9b59416d0d Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sun, 21 Mar 2021 17:51:55 +0100
Subject: moved cell stuff to another file

---
 src/cell.rs | 207 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 207 insertions(+)
 create mode 100644 src/cell.rs

(limited to 'src/cell.rs')

diff --git a/src/cell.rs b/src/cell.rs
new file mode 100644
index 0000000..6b42fdf
--- /dev/null
+++ b/src/cell.rs
@@ -0,0 +1,207 @@
+use crate::constants;
+use bevy::prelude::*;
+use rand::{
+    distributions::{Distribution, Standard},
+    Rng,
+};
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum Occupant {
+    None,
+    Green,
+    Yellow,
+    Red,
+    Diamond,
+    Explosion,
+}
+
+impl Default for Occupant {
+    fn default() -> Occupant {
+        Occupant::None
+    }
+}
+
+impl Occupant {
+    pub fn to_index(&self) -> u32 {
+        match self {
+            Occupant::Green => 0,
+            Occupant::Yellow => 1,
+            Occupant::Red => 2,
+            Occupant::Diamond => 3,
+            Occupant::Explosion => 4,
+            Occupant::None => 13,
+        }
+    }
+}
+
+impl Distribution<Occupant> for Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Occupant {
+        match rng.gen_range(0..=3) {
+            0 => Occupant::Green,
+            1 => Occupant::Yellow,
+            2 => Occupant::Diamond,
+            3 => Occupant::Red,
+            _ => Occupant::None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default, Copy)]
+pub struct Cell {
+    pub x: usize,
+    pub y: usize,
+    pub occupant: Occupant,
+    pub selected: bool,
+    pub hovered: bool,
+}
+
+impl Cell {
+    pub fn new(x: usize, y: usize) -> Cell {
+        Cell {
+            x,
+            y,
+            occupant: Occupant::None,
+            selected: false,
+            hovered: false,
+        }
+    }
+}
+
+pub fn insert(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
+    for (mut cell, mut sprite) in cell_query.iter_mut() {
+        if cell.occupant == Occupant::None && cell.y == constants::ROWS - 1 {
+            cell.occupant = rand::random();
+            sprite.index = cell.occupant.to_index();
+        }
+    }
+}
+
+pub fn explosion_animation(
+    time: Res<Time>,
+    commands: &mut Commands,
+    mut cell_query: Query<(
+        Entity,
+        &mut Cell,
+        &mut TextureAtlasSprite,
+        Option<&mut Timer>,
+    )>,
+) {
+    for (entity, mut cell, mut sprite, timer) in cell_query.iter_mut() {
+        if cell.occupant == Occupant::Explosion {
+            if let Some(mut timer) = timer {
+                timer.tick(time.delta_seconds());
+                if timer.finished() {
+                    if sprite.index < 7 && sprite.index >= 4 {
+                        sprite.index += 1;
+                    } else {
+                        cell.occupant = Occupant::None;
+                        sprite.index = cell.occupant.to_index();
+                        commands.remove_one::<Timer>(entity);
+                    }
+                }
+            } else {
+                commands.insert(entity, (Timer::from_seconds(0.1, true),));
+            }
+        }
+    }
+}
+
+pub fn check(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
+    let mut cells = [[Cell::default(); constants::COLUMNS]; constants::ROWS];
+    for (cell, _) in cell_query.iter_mut() {
+        cells[cell.x][cell.y] = *cell;
+    }
+
+    let mut last = Occupant::None;
+    let mut connected = Vec::new();
+
+    for (i, _) in cells.iter().enumerate() {
+        let mut c = Vec::new();
+        for j in 0..constants::ROWS {
+            if cells[i][j].occupant == last && last != Occupant::None {
+                c.push((i, j));
+                c.push((i, j - 1));
+            } else {
+                connected.push(c.clone());
+                c.clear();
+            }
+            last = cells[i][j].occupant;
+        }
+        connected.push(c);
+        last = Occupant::None;
+    }
+
+    for c in connected.iter() {
+        if c.len() > 4 {
+            for (i, j) in c.iter() {
+                for (mut cell, mut sprite) in cell_query.iter_mut() {
+                    if &cell.x == i && &cell.y == j && cell.occupant != Occupant::Explosion {
+                        cell.occupant = Occupant::Explosion;
+                        sprite.index = cell.occupant.to_index();
+                    }
+                }
+            }
+        }
+    }
+
+    connected.clear();
+
+    for (i, row) in cells.iter().enumerate() {
+        let mut c = Vec::new();
+        for (j, _) in row.iter().enumerate() {
+            if cells[j][i].occupant == last && last != Occupant::None {
+                c.push((j, i));
+                c.push((j - 1, i));
+            } else {
+                connected.push(c.clone());
+                c.clear();
+            }
+            last = cells[j][i].occupant;
+        }
+        connected.push(c);
+        last = Occupant::None;
+    }
+
+    for c in connected.iter() {
+        if c.len() > 4 {
+            for (i, j) in c.iter() {
+                for (mut cell, mut sprite) in cell_query.iter_mut() {
+                    if &cell.x == i && &cell.y == j && cell.occupant != Occupant::Explosion {
+                        cell.occupant = Occupant::Explosion;
+                        sprite.index = cell.occupant.to_index();
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub fn falling(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
+    let mut have_gems = Vec::new();
+    for (cell, _sprite) in cell_query.iter_mut() {
+        if cell.occupant != Occupant::None {
+            have_gems.push(*cell);
+        }
+    }
+
+    let mut moved_gems = Vec::new();
+    for (mut cell, mut sprite) in cell_query.iter_mut() {
+        if cell.occupant == Occupant::None {
+            if let Some(c) = have_gems
+                .iter()
+                .find(|&c| (c.x, c.y) == (cell.x, cell.y + 1))
+            {
+                cell.occupant = c.occupant;
+                sprite.index = cell.occupant.to_index();
+                moved_gems.push(c);
+            }
+        }
+    }
+
+    for (mut cell, mut sprite) in cell_query.iter_mut() {
+        if moved_gems.iter().any(|c| (c.x, c.y) == (cell.x, cell.y)) {
+            cell.occupant = Occupant::None;
+            sprite.index = cell.occupant.to_index();
+        }
+    }
+}
-- 
cgit v1.2.3


From 4312f3b7eedbf6cdbe012be6eea1d45afd82de12 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sun, 21 Mar 2021 18:29:09 +0100
Subject: start using constants for the tilesheet indexes

---
 src/cell.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'src/cell.rs')

diff --git a/src/cell.rs b/src/cell.rs
index 6b42fdf..1659289 100644
--- a/src/cell.rs
+++ b/src/cell.rs
@@ -11,7 +11,7 @@ pub enum Occupant {
     Green,
     Yellow,
     Red,
-    Diamond,
+    Blue,
     Explosion,
 }
 
@@ -24,12 +24,12 @@ impl Default for Occupant {
 impl Occupant {
     pub fn to_index(&self) -> u32 {
         match self {
-            Occupant::Green => 0,
-            Occupant::Yellow => 1,
-            Occupant::Red => 2,
-            Occupant::Diamond => 3,
-            Occupant::Explosion => 4,
-            Occupant::None => 13,
+            Occupant::Green => constants::TILESHEET_GREEN,
+            Occupant::Yellow => constants::TILESHEET_YELLOW,
+            Occupant::Red => constants::TILESHEET_RED,
+            Occupant::Blue => constants::TILESHEET_BLUE,
+            Occupant::Explosion => constants::TILESHEET_EXPLOSION1,
+            Occupant::None => constants::TILESHEET_NONE1,
         }
     }
 }
@@ -39,7 +39,7 @@ impl Distribution<Occupant> for Standard {
         match rng.gen_range(0..=3) {
             0 => Occupant::Green,
             1 => Occupant::Yellow,
-            2 => Occupant::Diamond,
+            2 => Occupant::Blue,
             3 => Occupant::Red,
             _ => Occupant::None,
         }
-- 
cgit v1.2.3


From 420d0f36adeed7fa254497b49ef91a7574628082 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sun, 21 Mar 2021 18:45:36 +0100
Subject: merged animation systems

---
 src/cell.rs | 27 ++++-----------------------
 1 file changed, 4 insertions(+), 23 deletions(-)

(limited to 'src/cell.rs')

diff --git a/src/cell.rs b/src/cell.rs
index 1659289..d5d19e2 100644
--- a/src/cell.rs
+++ b/src/cell.rs
@@ -76,32 +76,13 @@ pub fn insert(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
     }
 }
 
-pub fn explosion_animation(
-    time: Res<Time>,
+pub fn start_explosion(
     commands: &mut Commands,
-    mut cell_query: Query<(
-        Entity,
-        &mut Cell,
-        &mut TextureAtlasSprite,
-        Option<&mut Timer>,
-    )>,
+    mut cell_query: Query<(Entity, &Cell), Without<Timer>>,
 ) {
-    for (entity, mut cell, mut sprite, timer) in cell_query.iter_mut() {
+    for (entity, cell) in cell_query.iter_mut() {
         if cell.occupant == Occupant::Explosion {
-            if let Some(mut timer) = timer {
-                timer.tick(time.delta_seconds());
-                if timer.finished() {
-                    if sprite.index < 7 && sprite.index >= 4 {
-                        sprite.index += 1;
-                    } else {
-                        cell.occupant = Occupant::None;
-                        sprite.index = cell.occupant.to_index();
-                        commands.remove_one::<Timer>(entity);
-                    }
-                }
-            } else {
-                commands.insert(entity, (Timer::from_seconds(0.1, true),));
-            }
+            commands.insert(entity, (Timer::from_seconds(0.1, true),));
         }
     }
 }
-- 
cgit v1.2.3


From 585d82473ccf566965ded0e50eea1669c3e1cdf3 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sun, 21 Mar 2021 19:33:05 +0100
Subject: moving more to constants

---
 src/cell.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'src/cell.rs')

diff --git a/src/cell.rs b/src/cell.rs
index d5d19e2..fc5d77d 100644
--- a/src/cell.rs
+++ b/src/cell.rs
@@ -69,7 +69,7 @@ impl Cell {
 
 pub fn insert(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
     for (mut cell, mut sprite) in cell_query.iter_mut() {
-        if cell.occupant == Occupant::None && cell.y == constants::ROWS - 1 {
+        if cell.occupant == Occupant::None && cell.y == constants::GRID_SIZE - 1 {
             cell.occupant = rand::random();
             sprite.index = cell.occupant.to_index();
         }
@@ -88,7 +88,7 @@ pub fn start_explosion(
 }
 
 pub fn check(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
-    let mut cells = [[Cell::default(); constants::COLUMNS]; constants::ROWS];
+    let mut cells = [[Cell::default(); constants::GRID_SIZE]; constants::GRID_SIZE];
     for (cell, _) in cell_query.iter_mut() {
         cells[cell.x][cell.y] = *cell;
     }
@@ -98,7 +98,7 @@ pub fn check(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
 
     for (i, _) in cells.iter().enumerate() {
         let mut c = Vec::new();
-        for j in 0..constants::ROWS {
+        for j in 0..constants::GRID_SIZE {
             if cells[i][j].occupant == last && last != Occupant::None {
                 c.push((i, j));
                 c.push((i, j - 1));
-- 
cgit v1.2.3


From 9a57ab99eb0162cbc55064639db69a1d9ff26d76 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sun, 21 Mar 2021 19:36:32 +0100
Subject: s/cell_query/q

---
 src/cell.rs | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

(limited to 'src/cell.rs')

diff --git a/src/cell.rs b/src/cell.rs
index fc5d77d..48bc387 100644
--- a/src/cell.rs
+++ b/src/cell.rs
@@ -67,8 +67,8 @@ impl Cell {
     }
 }
 
-pub fn insert(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
-    for (mut cell, mut sprite) in cell_query.iter_mut() {
+pub fn insert(mut q: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
+    for (mut cell, mut sprite) in q.iter_mut() {
         if cell.occupant == Occupant::None && cell.y == constants::GRID_SIZE - 1 {
             cell.occupant = rand::random();
             sprite.index = cell.occupant.to_index();
@@ -76,20 +76,17 @@ pub fn insert(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
     }
 }
 
-pub fn start_explosion(
-    commands: &mut Commands,
-    mut cell_query: Query<(Entity, &Cell), Without<Timer>>,
-) {
-    for (entity, cell) in cell_query.iter_mut() {
+pub fn start_explosion(commands: &mut Commands, mut q: Query<(Entity, &Cell), Without<Timer>>) {
+    for (entity, cell) in q.iter_mut() {
         if cell.occupant == Occupant::Explosion {
             commands.insert(entity, (Timer::from_seconds(0.1, true),));
         }
     }
 }
 
-pub fn check(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
+pub fn check(mut q: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
     let mut cells = [[Cell::default(); constants::GRID_SIZE]; constants::GRID_SIZE];
-    for (cell, _) in cell_query.iter_mut() {
+    for (cell, _) in q.iter_mut() {
         cells[cell.x][cell.y] = *cell;
     }
 
@@ -115,7 +112,7 @@ pub fn check(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
     for c in connected.iter() {
         if c.len() > 4 {
             for (i, j) in c.iter() {
-                for (mut cell, mut sprite) in cell_query.iter_mut() {
+                for (mut cell, mut sprite) in q.iter_mut() {
                     if &cell.x == i && &cell.y == j && cell.occupant != Occupant::Explosion {
                         cell.occupant = Occupant::Explosion;
                         sprite.index = cell.occupant.to_index();
@@ -146,7 +143,7 @@ pub fn check(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
     for c in connected.iter() {
         if c.len() > 4 {
             for (i, j) in c.iter() {
-                for (mut cell, mut sprite) in cell_query.iter_mut() {
+                for (mut cell, mut sprite) in q.iter_mut() {
                     if &cell.x == i && &cell.y == j && cell.occupant != Occupant::Explosion {
                         cell.occupant = Occupant::Explosion;
                         sprite.index = cell.occupant.to_index();
@@ -157,16 +154,16 @@ pub fn check(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
     }
 }
 
-pub fn falling(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
+pub fn falling(mut q: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
     let mut have_gems = Vec::new();
-    for (cell, _sprite) in cell_query.iter_mut() {
+    for (cell, _sprite) in q.iter_mut() {
         if cell.occupant != Occupant::None {
             have_gems.push(*cell);
         }
     }
 
     let mut moved_gems = Vec::new();
-    for (mut cell, mut sprite) in cell_query.iter_mut() {
+    for (mut cell, mut sprite) in q.iter_mut() {
         if cell.occupant == Occupant::None {
             if let Some(c) = have_gems
                 .iter()
@@ -179,7 +176,7 @@ pub fn falling(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
         }
     }
 
-    for (mut cell, mut sprite) in cell_query.iter_mut() {
+    for (mut cell, mut sprite) in q.iter_mut() {
         if moved_gems.iter().any(|c| (c.x, c.y) == (cell.x, cell.y)) {
             cell.occupant = Occupant::None;
             sprite.index = cell.occupant.to_index();
-- 
cgit v1.2.3


From 23ba31868d99f17f2736d57d9a0f7a0eec0a5415 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sun, 21 Mar 2021 19:54:39 +0100
Subject: simplified check system

---
 src/cell.rs | 39 +++++++++++++--------------------------
 1 file changed, 13 insertions(+), 26 deletions(-)

(limited to 'src/cell.rs')

diff --git a/src/cell.rs b/src/cell.rs
index 48bc387..51b68e8 100644
--- a/src/cell.rs
+++ b/src/cell.rs
@@ -93,10 +93,11 @@ pub fn check(mut q: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
     let mut last = Occupant::None;
     let mut connected = Vec::new();
 
-    for (i, _) in cells.iter().enumerate() {
+    for (i, row) in cells.iter().enumerate() {
         let mut c = Vec::new();
-        for j in 0..constants::GRID_SIZE {
-            if cells[i][j].occupant == last && last != Occupant::None {
+        for (j, _) in row.iter().enumerate() {
+            if cells[i][j].occupant == last && last != Occupant::None && last != Occupant::Explosion
+            {
                 c.push((i, j));
                 c.push((i, j - 1));
             } else {
@@ -109,25 +110,11 @@ pub fn check(mut q: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
         last = Occupant::None;
     }
 
-    for c in connected.iter() {
-        if c.len() > 4 {
-            for (i, j) in c.iter() {
-                for (mut cell, mut sprite) in q.iter_mut() {
-                    if &cell.x == i && &cell.y == j && cell.occupant != Occupant::Explosion {
-                        cell.occupant = Occupant::Explosion;
-                        sprite.index = cell.occupant.to_index();
-                    }
-                }
-            }
-        }
-    }
-
-    connected.clear();
-
     for (i, row) in cells.iter().enumerate() {
         let mut c = Vec::new();
         for (j, _) in row.iter().enumerate() {
-            if cells[j][i].occupant == last && last != Occupant::None {
+            if cells[j][i].occupant == last && last != Occupant::None && last != Occupant::Explosion
+            {
                 c.push((j, i));
                 c.push((j - 1, i));
             } else {
@@ -140,14 +127,14 @@ pub fn check(mut q: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
         last = Occupant::None;
     }
 
+    connected = connected.into_iter().filter(|c| c.len() > 4).collect();
+
     for c in connected.iter() {
-        if c.len() > 4 {
-            for (i, j) in c.iter() {
-                for (mut cell, mut sprite) in q.iter_mut() {
-                    if &cell.x == i && &cell.y == j && cell.occupant != Occupant::Explosion {
-                        cell.occupant = Occupant::Explosion;
-                        sprite.index = cell.occupant.to_index();
-                    }
+        for (i, j) in c.iter() {
+            for (mut cell, mut sprite) in q.iter_mut() {
+                if &cell.x == i && &cell.y == j && cell.occupant != Occupant::Explosion {
+                    cell.occupant = Occupant::Explosion;
+                    sprite.index = cell.occupant.to_index();
                 }
             }
         }
-- 
cgit v1.2.3


From f98dcf9582418de9c4dc888ca78e88f4c0471be8 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sun, 4 Apr 2021 12:47:43 +0200
Subject: good start, but seem to have an issue with queries connecting cells
 and textureatlassprite, their iters are always empty

---
 src/cell.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'src/cell.rs')

diff --git a/src/cell.rs b/src/cell.rs
index 51b68e8..b697076 100644
--- a/src/cell.rs
+++ b/src/cell.rs
@@ -76,10 +76,12 @@ pub fn insert(mut q: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
     }
 }
 
-pub fn start_explosion(commands: &mut Commands, mut q: Query<(Entity, &Cell), Without<Timer>>) {
+pub fn start_explosion(mut commands: Commands, mut q: Query<(Entity, &Cell), Without<Timer>>) {
     for (entity, cell) in q.iter_mut() {
         if cell.occupant == Occupant::Explosion {
-            commands.insert(entity, (Timer::from_seconds(0.1, true),));
+            commands
+                .entity(entity)
+                .insert(Timer::from_seconds(0.1, true));
         }
     }
 }
-- 
cgit v1.2.3


From 6f2cf244f8d92068963207205125f2167768ff53 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sat, 10 Apr 2021 12:28:16 +0200
Subject: setup for new tileset

---
 src/cell.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'src/cell.rs')

diff --git a/src/cell.rs b/src/cell.rs
index b697076..10c11f0 100644
--- a/src/cell.rs
+++ b/src/cell.rs
@@ -12,6 +12,7 @@ pub enum Occupant {
     Yellow,
     Red,
     Blue,
+    Purple,
     Explosion,
 }
 
@@ -28,6 +29,7 @@ impl Occupant {
             Occupant::Yellow => constants::TILESHEET_YELLOW,
             Occupant::Red => constants::TILESHEET_RED,
             Occupant::Blue => constants::TILESHEET_BLUE,
+            Occupant::Purple => constants::TILESHEET_PURPLE,
             Occupant::Explosion => constants::TILESHEET_EXPLOSION1,
             Occupant::None => constants::TILESHEET_NONE1,
         }
@@ -36,11 +38,12 @@ impl Occupant {
 
 impl Distribution<Occupant> for Standard {
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Occupant {
-        match rng.gen_range(0..=3) {
+        match rng.gen_range(0..=4) {
             0 => Occupant::Green,
             1 => Occupant::Yellow,
             2 => Occupant::Blue,
             3 => Occupant::Red,
+            4 => Occupant::Purple,
             _ => Occupant::None,
         }
     }
-- 
cgit v1.2.3


From 893805baa14972dc6c1c28170856097bb54bf280 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sat, 10 Apr 2021 13:06:25 +0200
Subject: redid how visibility works, moved setting occupants to a fucntion,
 setup animation function better

---
 src/cell.rs | 47 +++++++++++++++++++++++++++++------------------
 1 file changed, 29 insertions(+), 18 deletions(-)

(limited to 'src/cell.rs')

diff --git a/src/cell.rs b/src/cell.rs
index 10c11f0..e4be4ac 100644
--- a/src/cell.rs
+++ b/src/cell.rs
@@ -31,7 +31,7 @@ impl Occupant {
             Occupant::Blue => constants::TILESHEET_BLUE,
             Occupant::Purple => constants::TILESHEET_PURPLE,
             Occupant::Explosion => constants::TILESHEET_EXPLOSION1,
-            Occupant::None => constants::TILESHEET_NONE1,
+            Occupant::None => 0,
         }
     }
 }
@@ -68,13 +68,27 @@ impl Cell {
             hovered: false,
         }
     }
+
+    pub fn set_occupant(
+        &mut self,
+        occupant: Occupant,
+        sprite: &mut TextureAtlasSprite,
+        visible: &mut Visible,
+    ) {
+        self.occupant = occupant;
+        sprite.index = self.occupant.to_index();
+        if self.occupant == Occupant::None {
+            visible.is_visible = false;
+        } else {
+            visible.is_visible = true;
+        }
+    }
 }
 
-pub fn insert(mut q: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
-    for (mut cell, mut sprite) in q.iter_mut() {
+pub fn insert(mut q: Query<(&mut Cell, &mut TextureAtlasSprite, &mut Visible)>) {
+    for (mut cell, mut sprite, mut visible) in q.iter_mut() {
         if cell.occupant == Occupant::None && cell.y == constants::GRID_SIZE - 1 {
-            cell.occupant = rand::random();
-            sprite.index = cell.occupant.to_index();
+            cell.set_occupant(rand::random(), &mut sprite, &mut visible);
         }
     }
 }
@@ -89,9 +103,9 @@ pub fn start_explosion(mut commands: Commands, mut q: Query<(Entity, &Cell), Wit
     }
 }
 
-pub fn check(mut q: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
+pub fn check(mut q: Query<(&mut Cell, &mut TextureAtlasSprite, &mut Visible)>) {
     let mut cells = [[Cell::default(); constants::GRID_SIZE]; constants::GRID_SIZE];
-    for (cell, _) in q.iter_mut() {
+    for (cell, _, _) in q.iter_mut() {
         cells[cell.x][cell.y] = *cell;
     }
 
@@ -136,42 +150,39 @@ pub fn check(mut q: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
 
     for c in connected.iter() {
         for (i, j) in c.iter() {
-            for (mut cell, mut sprite) in q.iter_mut() {
+            for (mut cell, mut sprite, mut visible) in q.iter_mut() {
                 if &cell.x == i && &cell.y == j && cell.occupant != Occupant::Explosion {
-                    cell.occupant = Occupant::Explosion;
-                    sprite.index = cell.occupant.to_index();
+                    cell.set_occupant(Occupant::Explosion, &mut sprite, &mut visible);
                 }
             }
         }
     }
 }
 
-pub fn falling(mut q: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
+pub fn falling(mut q: Query<(&mut Cell, &mut TextureAtlasSprite, &mut Visible)>) {
     let mut have_gems = Vec::new();
-    for (cell, _sprite) in q.iter_mut() {
+    for (cell, _sprite, _visible) in q.iter_mut() {
         if cell.occupant != Occupant::None {
             have_gems.push(*cell);
         }
     }
 
     let mut moved_gems = Vec::new();
-    for (mut cell, mut sprite) in q.iter_mut() {
+    for (mut cell, mut sprite, mut visible) in q.iter_mut() {
         if cell.occupant == Occupant::None {
             if let Some(c) = have_gems
                 .iter()
                 .find(|&c| (c.x, c.y) == (cell.x, cell.y + 1))
             {
-                cell.occupant = c.occupant;
-                sprite.index = cell.occupant.to_index();
+                cell.set_occupant(c.occupant, &mut sprite, &mut visible);
                 moved_gems.push(c);
             }
         }
     }
 
-    for (mut cell, mut sprite) in q.iter_mut() {
+    for (mut cell, mut sprite, mut visible) in q.iter_mut() {
         if moved_gems.iter().any(|c| (c.x, c.y) == (cell.x, cell.y)) {
-            cell.occupant = Occupant::None;
-            sprite.index = cell.occupant.to_index();
+            cell.set_occupant(Occupant::None, &mut sprite, &mut visible);
         }
     }
 }
-- 
cgit v1.2.3