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 -----------------------------
 src/cosmonaut.rs | 110 ----------------------
 src/game.rs      | 271 -------------------------------------------------------
 src/lib.rs       |   3 -
 src/main.rs      |  14 +--
 5 files changed, 5 insertions(+), 536 deletions(-)
 delete mode 100644 src/cell.rs
 delete mode 100644 src/cosmonaut.rs
 delete mode 100644 src/game.rs

(limited to 'src')

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(())
-    }
-}
diff --git a/src/cosmonaut.rs b/src/cosmonaut.rs
deleted file mode 100644
index 235861e..0000000
--- a/src/cosmonaut.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use crate::constants;
-use ggez::graphics::{self, DrawParam, FilterMode, Image, Rect};
-use ggez::mint::{Point2, Vector2};
-use ggez::{Context, GameResult};
-use std::time::Instant;
-
-#[derive(Clone, Copy)]
-enum CosmonautFrames {
-    None,
-    One,
-    Two,
-    Three,
-    Four,
-}
-
-impl CosmonautFrames {
-    pub fn next(&mut self) {
-        *self = match self {
-            CosmonautFrames::None => CosmonautFrames::One,
-            CosmonautFrames::One => CosmonautFrames::Two,
-            CosmonautFrames::Two => CosmonautFrames::Three,
-            CosmonautFrames::Three => CosmonautFrames::Four,
-            CosmonautFrames::Four => CosmonautFrames::None,
-        };
-    }
-}
-
-pub struct Cosmonaut {
-    destination: Point2<f32>,
-    image: Image,
-    frame: CosmonautFrames,
-    timer: Instant,
-    scale: Vector2<f32>,
-}
-
-impl Cosmonaut {
-    pub fn new(context: &mut Context) -> GameResult<Cosmonaut> {
-        let mut image = Image::new(context, "/cosmonaut.png")?;
-        image.set_filter(FilterMode::Nearest);
-
-        Ok(Cosmonaut {
-            image,
-            destination: Point2 { x: 600.0, y: 200.0 },
-            frame: CosmonautFrames::None,
-            timer: Instant::now(),
-            scale: Vector2 {
-                x: constants::TILE_SCALE * 2.0,
-                y: constants::TILE_SCALE * 2.0,
-            },
-        })
-    }
-
-    pub fn draw(&self, context: &mut Context) -> GameResult {
-        graphics::draw(
-            context,
-            &self.image,
-            DrawParam::default()
-                .dest(self.destination)
-                .scale(self.scale)
-                .src(Rect::new(0.0, 0.0, 1.0 / 3.0, 1.0)),
-        )?;
-        let source = match self.frame {
-            CosmonautFrames::None => None,
-            CosmonautFrames::One => Some(Rect::new(1.0 / 3.0, 0.0, 1.0 / 3.0, 1.0 / 2.0)),
-            CosmonautFrames::Two => Some(Rect::new(2.0 / 3.0, 0.0, 1.0, 1.0 / 2.0)),
-            CosmonautFrames::Three => Some(Rect::new(1.0 / 3.0, 1.0 / 2.0, 1.0 / 3.0, 1.0 / 2.0)),
-            CosmonautFrames::Four => Some(Rect::new(2.0 / 3.0, 1.0 / 2.0, 1.0, 1.0)),
-        };
-        if let Some(source) = source {
-            graphics::draw(
-                context,
-                &self.image,
-                DrawParam::default()
-                    .dest(self.destination)
-                    .src(source)
-                    .scale(self.scale),
-            )?;
-        }
-
-        Ok(())
-    }
-
-    pub fn update(&mut self) {
-        match self.frame {
-            CosmonautFrames::None => (),
-            _ => {
-                if self.timer.elapsed().as_millis() > 50 {
-                    self.frame.next();
-                    self.timer = Instant::now();
-                }
-            }
-        }
-    }
-
-    pub fn start(&mut self) {
-        if let CosmonautFrames::None = self.frame {
-            if self.timer.elapsed().as_secs() > 5 {
-                self.timer = Instant::now();
-                self.frame.next()
-            }
-        }
-    }
-
-    pub fn contains(&self, position: Point2<f32>) -> bool {
-        position.x > self.destination.x
-            && position.y > self.destination.y
-            && position.x < self.destination.x + constants::TILE_WIDTH * constants::TILE_SCALE * 2.0
-            && position.y < self.destination.y + constants::TILE_WIDTH * constants::TILE_SCALE * 2.0
-    }
-}
diff --git a/src/game.rs b/src/game.rs
deleted file mode 100644
index 5b72d9d..0000000
--- a/src/game.rs
+++ /dev/null
@@ -1,271 +0,0 @@
-use ggez::event::EventHandler;
-use ggez::graphics::{self, spritebatch::SpriteBatch, DrawParam, FilterMode, Image, WrapMode};
-use ggez::input::mouse;
-use ggez::mint::Point2;
-use ggez::{Context, GameResult};
-use std::time::Instant;
-
-use crate::cell::{Cell, Occupant};
-use crate::constants;
-use crate::cosmonaut::Cosmonaut;
-
-pub struct Game {
-    selected: Option<(usize, usize)>,
-    spritebatch: SpriteBatch,
-    grid: Vec<Vec<Cell>>,
-    background: Image,
-    cosmonaut: Cosmonaut,
-}
-
-impl Game {
-    pub fn new(context: &mut Context) -> GameResult<Game> {
-        let mut background = Image::new(context, "/background.png")?;
-        background.set_filter(FilterMode::Nearest);
-
-        let mut image = Image::new(context, "/tileset.png")?;
-        image.set_filter(FilterMode::Nearest);
-        image.set_wrap(WrapMode::Mirror, WrapMode::Mirror);
-
-        let mut grid = Vec::new();
-        let mut y = 0.0;
-
-        for _ in 0..constants::COLUMNS {
-            let mut column = Vec::new();
-            for j in 0..constants::ROWS {
-                column.push(Cell::new(Point2 {
-                    x: (j as f32)
-                        * (constants::TILE_WIDTH * constants::TILE_SCALE + constants::BORDER_SIZE)
-                        + constants::SHIFT_X,
-                    y: y + constants::SHIFT_Y,
-                }));
-            }
-            y += constants::TILE_HEIGHT * constants::TILE_SCALE + constants::BORDER_SIZE;
-            grid.push(column);
-        }
-
-        Ok(Game {
-            grid,
-            selected: None,
-            cosmonaut: Cosmonaut::new(context)?,
-            spritebatch: SpriteBatch::new(image),
-            background,
-        })
-    }
-
-    fn update_explosions(&mut self) {
-        let mut last = Occupant::None;
-        let mut connected = Vec::new();
-        for i in 0..constants::COLUMNS {
-            let mut c = Vec::new();
-            for j in 0..constants::ROWS {
-                if self.grid[i][j].occupant == last && last != Occupant::None {
-                    c.push((i, j));
-                    c.push((i, j - 1));
-                } else {
-                    connected.push(c.clone());
-                    c.clear();
-                }
-                last = self.grid[i][j].occupant;
-            }
-            connected.push(c);
-            last = Occupant::None;
-        }
-
-        for c in connected.iter() {
-            if c.len() > 3 {
-                for (i, j) in c.iter() {
-                    self.grid[*i][*j].occupant = Occupant::Explosion {
-                        frame: 0,
-                        timer: Instant::now(),
-                    };
-                }
-            }
-        }
-
-        connected.clear();
-        for i in 0..constants::COLUMNS {
-            let mut c = Vec::new();
-            for j in 0..constants::ROWS {
-                if self.grid[j][i].occupant == last && last != Occupant::None {
-                    c.push((j, i));
-                    c.push((j - 1, i));
-                } else {
-                    connected.push(c.clone());
-                    c.clear();
-                }
-                last = self.grid[j][i].occupant;
-            }
-            connected.push(c);
-            last = Occupant::None;
-        }
-
-        for c in connected.iter() {
-            if c.len() > 3 {
-                for (j, i) in c.iter() {
-                    self.grid[*j][*i].occupant = Occupant::Explosion {
-                        frame: 0,
-                        timer: Instant::now(),
-                    };
-                }
-            }
-        }
-    }
-
-    fn update_dropping(&mut self) {
-        for i in 1..constants::COLUMNS {
-            for j in 0..constants::ROWS {
-                if self.grid[i][j].occupant == Occupant::None
-                    && self.grid[i - 1][j].occupant != Occupant::None
-                {
-                    self.grid[i][j].occupant = self.grid[i - 1][j].occupant;
-                    self.grid[i - 1][j].occupant = Occupant::None;
-                }
-            }
-        }
-    }
-
-    fn update_feeding(&mut self) {
-        for i in 0..constants::COLUMNS {
-            if self.grid[0][i].occupant == Occupant::None {
-                self.grid[0][i].occupant = rand::random();
-            }
-        }
-    }
-
-    fn update_frames(&mut self) {
-        for row in self.grid.iter_mut() {
-            for cell in row.iter_mut() {
-                let mut done = false;
-                if let Occupant::Explosion {
-                    ref mut frame,
-                    ref mut timer,
-                } = cell.occupant
-                {
-                    if timer.elapsed().as_millis() > 500 {
-                        if *frame < 4 {
-                            *frame += 1;
-                            *timer = Instant::now();
-                        } else {
-                            done = true;
-                        }
-                    }
-                }
-                if done {
-                    cell.occupant = Occupant::None;
-                }
-            }
-        }
-    }
-}
-
-impl EventHandler for Game {
-    fn update(&mut self, context: &mut Context) -> GameResult {
-        for row in self.grid.iter_mut() {
-            for cell in row.iter_mut() {
-                cell.hover_off();
-            }
-        }
-
-        let position = mouse::position(context);
-
-        if self.cosmonaut.contains(position) {
-            self.cosmonaut.start();
-        }
-
-        self.cosmonaut.update();
-
-        for row in self.grid.iter_mut() {
-            for cell in row.iter_mut() {
-                if cell.contains(position) {
-                    cell.hover_on();
-                }
-            }
-        }
-
-        self.update_explosions();
-        self.update_frames();
-        self.update_dropping();
-        self.update_feeding();
-
-        Ok(())
-    }
-
-    fn mouse_button_down_event(
-        &mut self,
-        _context: &mut Context,
-        button: mouse::MouseButton,
-        x: f32,
-        y: f32,
-    ) {
-        if button == mouse::MouseButton::Left {
-            let position = Point2 { x, y };
-            for (i, row) in self.grid.iter_mut().enumerate() {
-                for (j, cell) in row.iter_mut().enumerate() {
-                    if cell.contains(position) && cell.moveable() {
-                        self.selected = Some((i, j));
-                        cell.clicked_on();
-                    }
-                }
-            }
-        }
-    }
-
-    fn mouse_button_up_event(
-        &mut self,
-        _context: &mut Context,
-        button: mouse::MouseButton,
-        x: f32,
-        y: f32,
-    ) {
-        if button == mouse::MouseButton::Left {
-            for row in self.grid.iter_mut() {
-                for cell in row.iter_mut() {
-                    cell.clicked_off();
-                }
-            }
-
-            if let Some(selected) = self.selected {
-                let position = Point2 { x, y };
-                let mut swap = None;
-                for (i, row) in self.grid.iter_mut().enumerate() {
-                    for (j, cell) in row.iter_mut().enumerate() {
-                        if cell.contains(position)
-                            && cell.moveable()
-                            && (((i + 1 == selected.0) && (j == selected.1))
-                                || ((i.overflowing_sub(1).0 == selected.0) && (j == selected.1))
-                                || ((i == selected.0) && (j + 1 == selected.1))
-                                || ((i == selected.0) && (j.overflowing_sub(1)).0 == selected.1))
-                        {
-                            swap = Some((i, j));
-                        }
-                    }
-                }
-                if let Some((i, j)) = swap {
-                    let clone = self.grid[i][j].occupant;
-                    self.grid[i][j].occupant = self.grid[selected.0][selected.1].occupant;
-                    self.grid[selected.0][selected.1].occupant = clone;
-                    self.selected = None;
-                }
-            }
-        }
-    }
-
-    fn draw(&mut self, context: &mut Context) -> GameResult {
-        graphics::clear(context, [0.0, 0.0, 0.0, 1.0].into());
-        graphics::draw(context, &self.background, DrawParam::default())?;
-        self.cosmonaut.draw(context)?;
-
-        for row in self.grid.iter() {
-            for cell in row.iter() {
-                cell.draw(context, &mut self.spritebatch)?;
-            }
-        }
-
-        graphics::draw(context, &self.spritebatch, DrawParam::default())?;
-
-        self.spritebatch.clear();
-
-        graphics::present(context)?;
-        Ok(())
-    }
-}
diff --git a/src/lib.rs b/src/lib.rs
index 78bbb9a..0b6d2c4 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1 @@
-pub mod cell;
 pub mod constants;
-pub mod cosmonaut;
-pub mod game;
diff --git a/src/main.rs b/src/main.rs
index a1fee19..30df8fb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,12 +1,8 @@
-use ggez::event::{self};
-use ggez::{ContextBuilder, GameResult};
+use bevy::prelude::App;
 
-use gems::game::Game;
+struct Gem;
+struct Position { x: f32, y: f32}
 
-pub fn main() -> GameResult {
-    let (ref mut context, ref mut event_loop) = ContextBuilder::new("gems", "jw&tb")
-        .add_resource_path("./resources")
-        .build()?;
-    let game = &mut Game::new(context)?;
-    event::run(context, event_loop, game)
+pub fn main() {
+    App::build().run();
 }
-- 
cgit v1.2.3


From e131d553d2526edb7cffbe9f4ba48d9c6ae4e44f Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sat, 20 Mar 2021 11:17:52 +0100
Subject: draw background

---
 src/main.rs | 90 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 86 insertions(+), 4 deletions(-)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index 30df8fb..c4e40f9 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,8 +1,90 @@
-use bevy::prelude::App;
+use bevy::math::Vec3;
+use bevy::prelude::*;
+use gems::constants;
 
-struct Gem;
-struct Position { x: f32, y: f32}
+enum Occupant {
+    None,
+    Green,
+}
+
+struct Cell {
+    x: u8,
+    y: u8,
+    occupant: Occupant,
+}
+
+impl Cell {
+    pub fn new(x: u8, y: u8) -> Cell {
+        Cell {
+            x,
+            y,
+            occupant: Occupant::None,
+        }
+    }
+}
+
+struct Position {
+    x: f32,
+    y: f32,
+}
+
+pub fn add_cells(commands: &mut Commands) {
+    for i in 0..8 {
+        for j in 0..8 {
+            commands.spawn((
+                Cell::new(i, j),
+                Position {
+                    x: (i as f32 * constants::TILE_HEIGHT),
+                    y: (j as f32 * constants::TILE_WIDTH),
+                },
+            ));
+        }
+    }
+}
+
+pub fn add_background(
+    commands: &mut Commands,
+    asset_server: Res<AssetServer>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    let texture_handle = asset_server.load("background.png");
+    commands
+        .spawn(Camera2dBundle {
+            transform: Transform {
+                translation: Vec3{
+                    x: -40.0,
+                    y: 0.0,
+                    z: 0.0,
+                },
+                scale: Vec3::splat(0.3),
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+        .spawn(SpriteBundle {
+            material: materials.add(texture_handle.into()),
+            ..Default::default()
+        });
+}
+
+pub struct GemsPlugin;
+impl Plugin for GemsPlugin {
+    fn build(&self, app: &mut AppBuilder) {
+        app.add_startup_system(add_background.system());
+        app.add_startup_system(add_cells.system());
+    }
+}
 
 pub fn main() {
-    App::build().run();
+    App::build()
+        .add_resource(WindowDescriptor {
+            title: "gems".to_string(),
+            width: 800.0,
+            height: 600.0,
+            resizable: false,
+            ..Default::default()
+        })
+        .add_plugins(DefaultPlugins)
+        .add_plugin(GemsPlugin)
+        .run();
 }
-- 
cgit v1.2.3


From ec95776771d061c21af17686491181c78b7955c9 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sat, 20 Mar 2021 12:35:38 +0100
Subject: draw grid

---
 src/constants.rs |  2 +-
 src/main.rs      | 89 ++++++++++++++++++++++++++++++++++++++------------------
 2 files changed, 61 insertions(+), 30 deletions(-)

(limited to 'src')

diff --git a/src/constants.rs b/src/constants.rs
index f9a5003..5952fa5 100644
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -1,5 +1,5 @@
 pub const TILE_SCALE: f32 = 3.0;
-pub const TILE_HEIGHT: f32 = 16.0;
+pub const TILE_SIZE: f32 = 16.0;
 pub const TILE_WIDTH: f32 = 16.0;
 pub const BORDER_SIZE: f32 = 3.0;
 pub const SHIFT_X: f32 = 50.0;
diff --git a/src/main.rs b/src/main.rs
index c4e40f9..acecaad 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -23,55 +23,86 @@ impl Cell {
     }
 }
 
-struct Position {
-    x: f32,
-    y: f32,
-}
-
-pub fn add_cells(commands: &mut Commands) {
-    for i in 0..8 {
-        for j in 0..8 {
-            commands.spawn((
-                Cell::new(i, j),
-                Position {
-                    x: (i as f32 * constants::TILE_HEIGHT),
-                    y: (j as f32 * constants::TILE_WIDTH),
-                },
-            ));
-        }
-    }
-}
-
-pub fn add_background(
+pub fn setup(
     commands: &mut Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
+    mut texture_atlases: ResMut<Assets<TextureAtlas>>,
 ) {
-    let texture_handle = asset_server.load("background.png");
+    let background = asset_server.load("background.png");
+    let tileset = asset_server.load("tileset.png");
+
+    let atlas = TextureAtlas::from_grid(tileset, Vec2::new(16.0, 16.0), 4, 4);
+    let atlas_handle = texture_atlases.add(atlas);
+
     commands
-        .spawn(Camera2dBundle {
+        .spawn(Camera2dBundle::default())
+        .spawn(SpriteBundle {
+            material: materials.add(background.into()),
             transform: Transform {
-                translation: Vec3{
-                    x: -40.0,
+                translation: Vec3 {
+                    x: 50.0,
                     y: 0.0,
                     z: 0.0,
                 },
-                scale: Vec3::splat(0.3),
+                scale: Vec3::splat(3.5),
                 ..Default::default()
             },
             ..Default::default()
         })
-        .spawn(SpriteBundle {
-            material: materials.add(texture_handle.into()),
+        .spawn(SpriteSheetBundle {
+            sprite: TextureAtlasSprite::new(8),
+            texture_atlas: atlas_handle.clone(),
+            transform: Transform {
+                translation: Vec3 {
+                    x: 225.0,
+                    y: -200.0,
+                    z: 0.0,
+                },
+                scale: Vec3::splat(3.5),
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+        .spawn(SpriteSheetBundle {
+            sprite: TextureAtlasSprite::new(12),
+            texture_atlas: atlas_handle.clone(),
+            transform: Transform {
+                translation: Vec3 {
+                    x: 225.0,
+                    y: -200.0 + (-16.0) * 3.5,
+                    z: 0.0,
+                },
+                scale: Vec3::splat(3.5),
+                ..Default::default()
+            },
             ..Default::default()
         });
+
+    for i in 0..8 {
+        for j in 0..8 {
+            commands.spawn(SpriteSheetBundle {
+                sprite: TextureAtlasSprite::new(1),
+                texture_atlas: atlas_handle.clone(),
+                transform: Transform {
+                    translation: Vec3 {
+                        x: ((i as f32) * 16.0 * 3.5) - 320.0,
+                        y: ((j as f32) * 16.0 * 3.5) - 170.0,
+                        z: 0.0,
+                    },
+                    scale: Vec3::splat(3.5),
+                    ..Default::default()
+                },
+                ..Default::default()
+            });
+        }
+    }
 }
 
 pub struct GemsPlugin;
 impl Plugin for GemsPlugin {
     fn build(&self, app: &mut AppBuilder) {
-        app.add_startup_system(add_background.system());
-        app.add_startup_system(add_cells.system());
+        app.add_startup_system(setup.system());
     }
 }
 
-- 
cgit v1.2.3


From baad8b54bdff624b648af7bcf977f14711ff59bc Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sat, 20 Mar 2021 14:00:10 +0100
Subject: populate top row with new gems

---
 src/main.rs | 72 ++++++++++++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 59 insertions(+), 13 deletions(-)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index acecaad..f3d41b0 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,12 +1,44 @@
 use bevy::math::Vec3;
 use bevy::prelude::*;
-use gems::constants;
+use rand::{
+    distributions::{Distribution, Standard},
+    Rng,
+};
 
+#[derive(Debug, PartialEq)]
 enum Occupant {
     None,
     Green,
+    Yellow,
+    Red,
+    Diamond,
 }
 
+impl Occupant {
+    pub fn to_index(&self) -> u32 {
+        match self {
+            Occupant::Green => 0,
+            Occupant::Yellow => 1,
+            Occupant::Red => 2,
+            Occupant::Diamond => 3,
+            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)]
 struct Cell {
     x: u8,
     y: u8,
@@ -23,6 +55,17 @@ impl Cell {
     }
 }
 
+fn cell_falling_system(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
+    for (mut cell, mut sprite) in cell_query.iter_mut() {
+        if cell.occupant == Occupant::None {
+            if cell.y == 7 {
+                cell.occupant = rand::random();
+                sprite.index = cell.occupant.to_index();
+            }
+        }
+    }
+}
+
 pub fn setup(
     commands: &mut Commands,
     asset_server: Res<AssetServer>,
@@ -81,20 +124,22 @@ pub fn setup(
 
     for i in 0..8 {
         for j in 0..8 {
-            commands.spawn(SpriteSheetBundle {
-                sprite: TextureAtlasSprite::new(1),
-                texture_atlas: atlas_handle.clone(),
-                transform: Transform {
-                    translation: Vec3 {
-                        x: ((i as f32) * 16.0 * 3.5) - 320.0,
-                        y: ((j as f32) * 16.0 * 3.5) - 170.0,
-                        z: 0.0,
+            commands
+                .spawn(SpriteSheetBundle {
+                    texture_atlas: atlas_handle.clone(),
+                    sprite: TextureAtlasSprite::new(11),
+                    transform: Transform {
+                        translation: Vec3 {
+                            x: ((i as f32) * 16.0 * 3.5) - 320.0,
+                            y: ((j as f32) * 16.0 * 3.5) - 160.0,
+                            z: 0.0,
+                        },
+                        scale: Vec3::splat(3.5),
+                        ..Default::default()
                     },
-                    scale: Vec3::splat(3.5),
                     ..Default::default()
-                },
-                ..Default::default()
-            });
+                })
+                .with(Cell::new(i, j));
         }
     }
 }
@@ -103,6 +148,7 @@ pub struct GemsPlugin;
 impl Plugin for GemsPlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.add_startup_system(setup.system());
+        app.add_system(cell_falling_system.system());
     }
 }
 
-- 
cgit v1.2.3


From 4fe231fcc252f19e3fa5e50d369571f1caf6ad33 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sat, 20 Mar 2021 15:35:18 +0100
Subject: gems now fall

---
 src/main.rs | 37 ++++++++++++++++++++++++++++++++++---
 1 file changed, 34 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index f3d41b0..56f2ea9 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,7 +5,7 @@ use rand::{
     Rng,
 };
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 enum Occupant {
     None,
     Green,
@@ -38,7 +38,7 @@ impl Distribution<Occupant> for Standard {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 struct Cell {
     x: u8,
     y: u8,
@@ -55,7 +55,7 @@ impl Cell {
     }
 }
 
-fn cell_falling_system(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
+fn cell_insert_system(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
     for (mut cell, mut sprite) in cell_query.iter_mut() {
         if cell.occupant == Occupant::None {
             if cell.y == 7 {
@@ -66,6 +66,36 @@ fn cell_falling_system(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite
     }
 }
 
+fn cell_falling_system(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.clone());
+        }
+    }
+
+    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.clone();
+                sprite.index = cell.occupant.to_index();
+                moved_gems.push(c.clone());
+            }
+        }
+    }
+
+    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();
+        }
+    }
+}
+
 pub fn setup(
     commands: &mut Commands,
     asset_server: Res<AssetServer>,
@@ -148,6 +178,7 @@ pub struct GemsPlugin;
 impl Plugin for GemsPlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.add_startup_system(setup.system());
+        app.add_system(cell_insert_system.system());
         app.add_system(cell_falling_system.system());
     }
 }
-- 
cgit v1.2.3


From c657649cdc1a4159f2c76852b32fc563d1279509 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sat, 20 Mar 2021 16:11:32 +0100
Subject: added check system

---
 src/main.rs | 106 ++++++++++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 92 insertions(+), 14 deletions(-)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index 56f2ea9..c81203f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,17 +1,25 @@
 use bevy::math::Vec3;
 use bevy::prelude::*;
+use gems::constants;
 use rand::{
     distributions::{Distribution, Standard},
     Rng,
 };
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 enum Occupant {
     None,
     Green,
     Yellow,
     Red,
     Diamond,
+    Explosion,
+}
+
+impl Default for Occupant {
+    fn default() -> Occupant {
+        Occupant::None
+    }
 }
 
 impl Occupant {
@@ -21,6 +29,7 @@ impl Occupant {
             Occupant::Yellow => 1,
             Occupant::Red => 2,
             Occupant::Diamond => 3,
+            Occupant::Explosion => 4,
             Occupant::None => 13,
         }
     }
@@ -38,15 +47,15 @@ impl Distribution<Occupant> for Standard {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default, Copy)]
 struct Cell {
-    x: u8,
-    y: u8,
+    x: usize,
+    y: usize,
     occupant: Occupant,
 }
 
 impl Cell {
-    pub fn new(x: u8, y: u8) -> Cell {
+    pub fn new(x: usize, y: usize) -> Cell {
         Cell {
             x,
             y,
@@ -57,10 +66,78 @@ impl Cell {
 
 fn cell_insert_system(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
     for (mut cell, mut sprite) in cell_query.iter_mut() {
-        if cell.occupant == Occupant::None {
-            if cell.y == 7 {
-                cell.occupant = rand::random();
-                sprite.index = cell.occupant.to_index();
+        if cell.occupant == Occupant::None && cell.y == constants::ROWS - 1 {
+            cell.occupant = rand::random();
+            sprite.index = cell.occupant.to_index();
+        }
+    }
+}
+
+fn cell_check_system(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() > 3 {
+            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;
+                        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() > 3 {
+            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;
+                        sprite.index = cell.occupant.to_index();
+                    }
+                }
             }
         }
     }
@@ -70,7 +147,7 @@ fn cell_falling_system(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.clone());
+            have_gems.push(*cell);
         }
     }
 
@@ -81,9 +158,9 @@ fn cell_falling_system(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite
                 .iter()
                 .find(|&c| (c.x, c.y) == (cell.x, cell.y + 1))
             {
-                cell.occupant = c.occupant.clone();
+                cell.occupant = c.occupant;
                 sprite.index = cell.occupant.to_index();
-                moved_gems.push(c.clone());
+                moved_gems.push(c);
             }
         }
     }
@@ -152,8 +229,8 @@ pub fn setup(
             ..Default::default()
         });
 
-    for i in 0..8 {
-        for j in 0..8 {
+    for i in 0..constants::COLUMNS {
+        for j in 0..constants::ROWS {
             commands
                 .spawn(SpriteSheetBundle {
                     texture_atlas: atlas_handle.clone(),
@@ -180,6 +257,7 @@ impl Plugin for GemsPlugin {
         app.add_startup_system(setup.system());
         app.add_system(cell_insert_system.system());
         app.add_system(cell_falling_system.system());
+        app.add_system(cell_check_system.system());
     }
 }
 
-- 
cgit v1.2.3


From c24bf56c3d69b826078307ddebb129a7be99ad97 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sat, 20 Mar 2021 17:22:49 +0100
Subject: explosion animation system

---
 src/main.rs | 39 +++++++++++++++++++++++++++++++++++----
 1 file changed, 35 insertions(+), 4 deletions(-)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index c81203f..4df4fa7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -73,6 +73,36 @@ fn cell_insert_system(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)
     }
 }
 
+fn explosion_animation_system(
+    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),));
+            }
+        }
+    }
+}
+
 fn cell_check_system(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
     let mut cells = [[Cell::default(); constants::COLUMNS]; constants::ROWS];
     for (cell, _) in cell_query.iter_mut() {
@@ -99,10 +129,10 @@ fn cell_check_system(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>
     }
 
     for c in connected.iter() {
-        if c.len() > 3 {
+        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 {
+                    if &cell.x == i && &cell.y == j && cell.occupant != Occupant::Explosion {
                         cell.occupant = Occupant::Explosion;
                         sprite.index = cell.occupant.to_index();
                     }
@@ -130,10 +160,10 @@ fn cell_check_system(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>
     }
 
     for c in connected.iter() {
-        if c.len() > 3 {
+        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 {
+                    if &cell.x == i && &cell.y == j && cell.occupant != Occupant::Explosion {
                         cell.occupant = Occupant::Explosion;
                         sprite.index = cell.occupant.to_index();
                     }
@@ -258,6 +288,7 @@ impl Plugin for GemsPlugin {
         app.add_system(cell_insert_system.system());
         app.add_system(cell_falling_system.system());
         app.add_system(cell_check_system.system());
+        app.add_system(explosion_animation_system.system());
     }
 }
 
-- 
cgit v1.2.3


From 3449202489951dc0ca43428062439d34f5fc2e8a Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sun, 21 Mar 2021 14:16:03 +0100
Subject: mouse hover over gems

---
 src/main.rs | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index 4df4fa7..bb65f81 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -281,6 +281,33 @@ pub fn setup(
     }
 }
 
+fn mouse_system(
+    windows: Res<Windows>,
+    mut cell_query: Query<(&Cell, &mut Transform, &mut TextureAtlasSprite)>,
+) {
+    if let Some(mut cursor_position) = windows
+        .get_primary()
+        .and_then(|window| window.cursor_position())
+    {
+        cursor_position.x -= 400.0 - 16.0 * 3.5 * 0.5;
+        cursor_position.y -= 300.0 - 16.0 * 3.5 * 0.5;
+
+        for (_, _, mut sprite) in cell_query.iter_mut() {
+            sprite.color.set_a(1.0);
+        }
+
+        for (_, transform, mut sprite) in cell_query.iter_mut() {
+            if transform.translation.x < cursor_position.x
+                && transform.translation.x + 16.0 * 3.5 > cursor_position.x
+                && transform.translation.y < cursor_position.y
+                && transform.translation.y + 16.0 * 3.5 > cursor_position.y
+            {
+                sprite.color.set_a(0.5);
+            }
+        }
+    }
+}
+
 pub struct GemsPlugin;
 impl Plugin for GemsPlugin {
     fn build(&self, app: &mut AppBuilder) {
@@ -289,6 +316,7 @@ impl Plugin for GemsPlugin {
         app.add_system(cell_falling_system.system());
         app.add_system(cell_check_system.system());
         app.add_system(explosion_animation_system.system());
+        app.add_system(mouse_system.system());
     }
 }
 
-- 
cgit v1.2.3


From d3ae44a367de28934f64155be7b4f04bd63db1dc Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sun, 21 Mar 2021 15:43:13 +0100
Subject: can now move gems

---
 src/main.rs | 57 +++++++++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 53 insertions(+), 4 deletions(-)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index bb65f81..d9a468f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -52,6 +52,8 @@ struct Cell {
     x: usize,
     y: usize,
     occupant: Occupant,
+    selected: bool,
+    hovered: bool,
 }
 
 impl Cell {
@@ -60,6 +62,8 @@ impl Cell {
             x,
             y,
             occupant: Occupant::None,
+            selected: false,
+            hovered: false,
         }
     }
 }
@@ -283,7 +287,8 @@ pub fn setup(
 
 fn mouse_system(
     windows: Res<Windows>,
-    mut cell_query: Query<(&Cell, &mut Transform, &mut TextureAtlasSprite)>,
+    mut cell_query: Query<(&mut Cell, &mut Transform, &mut TextureAtlasSprite)>,
+    mouse_button_input: Res<Input<MouseButton>>,
 ) {
     if let Some(mut cursor_position) = windows
         .get_primary()
@@ -292,17 +297,61 @@ fn mouse_system(
         cursor_position.x -= 400.0 - 16.0 * 3.5 * 0.5;
         cursor_position.y -= 300.0 - 16.0 * 3.5 * 0.5;
 
-        for (_, _, mut sprite) in cell_query.iter_mut() {
-            sprite.color.set_a(1.0);
+        for (cell, _, mut sprite) in cell_query.iter_mut() {
+            if cell.selected {
+                sprite.color.set_a(0.2);
+            } else if cell.hovered {
+                sprite.color.set_a(0.5);
+            } else {
+                sprite.color.set_a(1.0);
+            }
         }
 
-        for (_, transform, mut sprite) in cell_query.iter_mut() {
+        for (mut cell, transform, mut sprite) in cell_query.iter_mut() {
             if transform.translation.x < cursor_position.x
                 && transform.translation.x + 16.0 * 3.5 > cursor_position.x
                 && transform.translation.y < cursor_position.y
                 && transform.translation.y + 16.0 * 3.5 > cursor_position.y
             {
+                cell.hovered = true;
                 sprite.color.set_a(0.5);
+                if mouse_button_input.just_pressed(MouseButton::Left) {
+                    cell.selected = true;
+                }
+            } else {
+                cell.hovered = false;
+            }
+        }
+
+        if mouse_button_input.just_released(MouseButton::Left) {
+            let mut cells: Vec<Cell> = Vec::new();
+            for (cell, _, _) in cell_query.iter_mut() {
+                cells.push(*cell);
+            }
+            if let Some(mut selected) = cells.clone().iter_mut().find(|c| c.selected) {
+                if let Some(mut hovered) = cells.iter_mut().find(|c| c.hovered) {
+                    if (selected.x == hovered.x + 1 && selected.y == hovered.y)
+                        || (selected.x == hovered.x - 1 && selected.y == hovered.y)
+                        || (selected.y == hovered.y + 1 && selected.x == hovered.x)
+                        || (selected.y == hovered.y - 1 && selected.x == hovered.x)
+                    {
+                        let tmp = selected.occupant;
+                        selected.occupant = hovered.occupant;
+                        hovered.occupant = tmp;
+                        for (mut cell, _, mut sprite) in cell_query.iter_mut() {
+                            if cell.x == selected.x && cell.y == selected.y {
+                                cell.occupant = selected.occupant;
+                                sprite.index = cell.occupant.to_index();
+                            } else if cell.x == hovered.x && cell.y == hovered.y {
+                                cell.occupant = hovered.occupant;
+                                sprite.index = cell.occupant.to_index();
+                            }
+                        }
+                    }
+                }
+            }
+            for (mut cell, _, _) in cell_query.iter_mut() {
+                cell.selected = false;
             }
         }
     }
-- 
cgit v1.2.3


From 5198891f3683c656f8e50a99a3a271b4e0734293 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sun, 21 Mar 2021 16:18:52 +0100
Subject: visor animation with hover

---
 src/main.rs | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index d9a468f..5577a11 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -285,6 +285,60 @@ pub fn setup(
     }
 }
 
+fn cosmonaut_animation_system(
+    commands: &mut Commands,
+    time: Res<Time>,
+    mut cell_query: Query<(Entity, &mut Timer, &mut TextureAtlasSprite), Without<Cell>>,
+) {
+    for (entity, mut timer, mut sprite) in cell_query.iter_mut() {
+        timer.tick(time.delta_seconds());
+        if timer.finished() {
+            let index = match sprite.index {
+                9 => 10,
+                10 => 13,
+                13 => 14,
+                11 => 12,
+                _ => 11,
+            };
+            sprite.index = index;
+            if index == 12 {
+                commands.remove_one::<Timer>(entity);
+                commands.remove_one::<TextureAtlasSprite>(entity);
+            }
+        }
+    }
+}
+
+fn cosmonaut_detect_system(
+    commands: &mut Commands,
+    windows: Res<Windows>,
+    mut cell_query: Query<(&Transform, &TextureAtlasSprite)>,
+) {
+    if let Some(mut cursor_position) = windows
+        .get_primary()
+        .and_then(|window| window.cursor_position())
+    {
+        cursor_position.x -= 400.0 - 16.0 * 3.5 * 0.5;
+        cursor_position.y -= 300.0 - 16.0 * 3.5 * 0.5;
+        for (transform, sprite) in cell_query.iter_mut() {
+            if transform.translation.x < cursor_position.x
+                && transform.translation.x + 16.0 * 3.5 > cursor_position.x
+                && transform.translation.y < cursor_position.y
+                && transform.translation.y + 16.0 * 3.5 > cursor_position.y
+                && sprite.index == 8
+            {
+                commands
+                    .spawn(SpriteSheetBundle {
+                        sprite: TextureAtlasSprite::new(9),
+                        transform: *transform,
+                        ..Default::default()
+                    })
+                    .with(Timer::from_seconds(0.1, true));
+            }
+        }
+    }
+}
+
 fn mouse_system(
     windows: Res<Windows>,
     mut cell_query: Query<(&mut Cell, &mut Transform, &mut TextureAtlasSprite)>,
@@ -366,6 +420,8 @@ impl Plugin for GemsPlugin {
         app.add_system(cell_check_system.system());
         app.add_system(explosion_animation_system.system());
         app.add_system(mouse_system.system());
+        app.add_system(cosmonaut_detect_system.system());
+        app.add_system(cosmonaut_animation_system.system());
     }
 }
 
-- 
cgit v1.2.3


From 42c0f017348ef2033b6889b272f31f0c5eb5d41d Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sun, 21 Mar 2021 17:16:19 +0100
Subject: added twinkling stars

---
 src/main.rs | 44 +++++++++++++++++++++++++++++++++++++-------
 1 file changed, 37 insertions(+), 7 deletions(-)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index 5577a11..bab21a0 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 use gems::constants;
 use rand::{
     distributions::{Distribution, Standard},
-    Rng,
+    thread_rng, Rng,
 };
 
 #[derive(Debug, PartialEq, Clone, Copy)]
@@ -177,6 +177,33 @@ fn cell_check_system(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>
     }
 }
 
+fn star_spawning_system(commands: &mut Commands, time: Res<Time>, mut q: Query<&mut Timer>) {
+    for mut timer in q.iter_mut() {
+        if !timer.repeating() {
+            timer.tick(time.delta_seconds());
+            if timer.just_finished() {
+                timer.set_duration(thread_rng().gen_range(2..5) as f32);
+                timer.reset();
+                commands
+                    .spawn(SpriteSheetBundle {
+                        sprite: TextureAtlasSprite::new(16),
+                        transform: Transform {
+                            translation: Vec3 {
+                                x: thread_rng().gen_range(-300..300) as f32,
+                                y: thread_rng().gen_range(-200..300) as f32,
+                                z: 0.0,
+                            },
+                            scale: Vec3::splat(thread_rng().gen_range(1..3) as f32),
+                            ..Default::default()
+                        },
+                        ..Default::default()
+                    })
+                    .with(Timer::from_seconds(0.25, true));
+            }
+        }
+    }
+}
+
 fn cell_falling_system(mut cell_query: Query<(&mut Cell, &mut TextureAtlasSprite)>) {
     let mut have_gems = Vec::new();
     for (cell, _sprite) in cell_query.iter_mut() {
@@ -216,7 +243,7 @@ pub fn setup(
     let background = asset_server.load("background.png");
     let tileset = asset_server.load("tileset.png");
 
-    let atlas = TextureAtlas::from_grid(tileset, Vec2::new(16.0, 16.0), 4, 4);
+    let atlas = TextureAtlas::from_grid(tileset, Vec2::new(16.0, 16.0), 4, 5);
     let atlas_handle = texture_atlases.add(atlas);
 
     commands
@@ -248,6 +275,7 @@ pub fn setup(
             },
             ..Default::default()
         })
+        .spawn((Timer::from_seconds(1.0, false),))
         .spawn(SpriteSheetBundle {
             sprite: TextureAtlasSprite::new(12),
             texture_atlas: atlas_handle.clone(),
@@ -273,7 +301,7 @@ pub fn setup(
                         translation: Vec3 {
                             x: ((i as f32) * 16.0 * 3.5) - 320.0,
                             y: ((j as f32) * 16.0 * 3.5) - 160.0,
-                            z: 0.0,
+                            z: 1.0,
                         },
                         scale: Vec3::splat(3.5),
                         ..Default::default()
@@ -285,7 +313,7 @@ pub fn setup(
     }
 }
 
-fn cosmonaut_animation_system(
+fn animation_system(
     commands: &mut Commands,
     time: Res<Time>,
     mut cell_query: Query<(Entity, &mut Timer, &mut TextureAtlasSprite), Without<Cell>>,
@@ -298,12 +326,13 @@ fn cosmonaut_animation_system(
                 10 => 13,
                 13 => 14,
                 11 => 12,
+                16 => 17,
+                17 => 18,
                 _ => 11,
             };
             sprite.index = index;
             if index == 12 {
-                commands.remove_one::<Timer>(entity);
-                commands.remove_one::<TextureAtlasSprite>(entity);
+                commands.despawn(entity);
             }
         }
     }
@@ -421,7 +450,8 @@ impl Plugin for GemsPlugin {
         app.add_system(explosion_animation_system.system());
         app.add_system(mouse_system.system());
         app.add_system(cosmonaut_detect_system.system());
-        app.add_system(cosmonaut_animation_system.system());
+        app.add_system(animation_system.system());
+        app.add_system(star_spawning_system.system());
     }
 }
 
-- 
cgit v1.2.3


From 911032cb80a6aeff5549e1038e19d0e0524abd3c Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sun, 21 Mar 2021 17:24:51 +0100
Subject: fixed overflow issue

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

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index bab21a0..f0a7eb6 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -414,9 +414,9 @@ fn mouse_system(
             if let Some(mut selected) = cells.clone().iter_mut().find(|c| c.selected) {
                 if let Some(mut hovered) = cells.iter_mut().find(|c| c.hovered) {
                     if (selected.x == hovered.x + 1 && selected.y == hovered.y)
-                        || (selected.x == hovered.x - 1 && selected.y == hovered.y)
+                        || (selected.x == hovered.x.overflowing_sub(1).0 && selected.y == hovered.y)
                         || (selected.y == hovered.y + 1 && selected.x == hovered.x)
-                        || (selected.y == hovered.y - 1 && selected.x == hovered.x)
+                        || (selected.y == hovered.y.overflowing_sub(1).0 && selected.x == hovered.x)
                     {
                         let tmp = selected.occupant;
                         selected.occupant = hovered.occupant;
-- 
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 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/lib.rs  |   1 +
 src/main.rs | 215 ++----------------------------------------------------------
 3 files changed, 214 insertions(+), 209 deletions(-)
 create mode 100644 src/cell.rs

(limited to 'src')

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();
+        }
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 0b6d2c4..b7fde1e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1 +1,2 @@
+pub mod cell;
 pub mod constants;
diff --git a/src/main.rs b/src/main.rs
index f0a7eb6..566ded5 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,181 +1,8 @@
 use bevy::math::Vec3;
 use bevy::prelude::*;
+use gems::cell::{self, Cell};
 use gems::constants;
-use rand::{
-    distributions::{Distribution, Standard},
-    thread_rng, Rng,
-};
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-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)]
-struct Cell {
-    x: usize,
-    y: usize,
-    occupant: Occupant,
-    selected: bool,
-    hovered: bool,
-}
-
-impl Cell {
-    pub fn new(x: usize, y: usize) -> Cell {
-        Cell {
-            x,
-            y,
-            occupant: Occupant::None,
-            selected: false,
-            hovered: false,
-        }
-    }
-}
-
-fn cell_insert_system(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();
-        }
-    }
-}
-
-fn explosion_animation_system(
-    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),));
-            }
-        }
-    }
-}
-
-fn cell_check_system(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();
-                    }
-                }
-            }
-        }
-    }
-}
+use rand::{thread_rng, Rng};
 
 fn star_spawning_system(commands: &mut Commands, time: Res<Time>, mut q: Query<&mut Timer>) {
     for mut timer in q.iter_mut() {
@@ -204,36 +31,6 @@ fn star_spawning_system(commands: &mut Commands, time: Res<Time>, mut q: Query<&
     }
 }
 
-fn cell_falling_system(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();
-        }
-    }
-}
-
 pub fn setup(
     commands: &mut Commands,
     asset_server: Res<AssetServer>,
@@ -444,10 +241,10 @@ pub struct GemsPlugin;
 impl Plugin for GemsPlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.add_startup_system(setup.system());
-        app.add_system(cell_insert_system.system());
-        app.add_system(cell_falling_system.system());
-        app.add_system(cell_check_system.system());
-        app.add_system(explosion_animation_system.system());
+        app.add_system(cell::insert.system());
+        app.add_system(cell::falling.system());
+        app.add_system(cell::check.system());
+        app.add_system(cell::explosion_animation.system());
         app.add_system(mouse_system.system());
         app.add_system(cosmonaut_detect_system.system());
         app.add_system(animation_system.system());
-- 
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 ++++++++--------
 src/constants.rs | 25 +++++++++++++++++++++++++
 src/main.rs      | 34 ++++++++++++++++++++--------------
 3 files changed, 53 insertions(+), 22 deletions(-)

(limited to 'src')

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,
         }
diff --git a/src/constants.rs b/src/constants.rs
index 5952fa5..c33e30b 100644
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -6,3 +6,28 @@ pub const SHIFT_X: f32 = 50.0;
 pub const SHIFT_Y: f32 = 50.0;
 pub const COLUMNS: usize = 8;
 pub const ROWS: usize = 8;
+
+pub const TILESHEET_GREEN: u32 = 0;
+pub const TILESHEET_YELLOW: u32 = 1;
+pub const TILESHEET_BLUE: u32 = 2;
+pub const TILESHEET_RED: u32 = 3;
+
+pub const TILESHEET_EXPLOSION1: u32 = 4;
+pub const TILESHEET_EXPLOSION2: u32 = 5;
+pub const TILESHEET_EXPLOSION3: u32 = 6;
+pub const TILESHEET_EXPLOSION4: u32 = 7;
+
+pub const TILESHEET_COSMONAUT1: u32 = 8;
+pub const TILESHEET_VISOR1: u32 = 9;
+pub const TILESHEET_VISOR2: u32 = 10;
+pub const TILESHEET_NONE1: u32 = 11;
+
+pub const TILESHEET_COSMONAUT2: u32 = 12;
+pub const TILESHEET_VISOR3: u32 = 13;
+pub const TILESHEET_VISOR4: u32 = 14;
+pub const TILESHEET_NONE2: u32 = 15;
+
+pub const TILESHEET_STAR1: u32 = 16;
+pub const TILESHEET_STAR2: u32 = 17;
+pub const TILESHEET_STAR3: u32 = 18;
+pub const TILESHEET_NONE3: u32 = 19;
diff --git a/src/main.rs b/src/main.rs
index 566ded5..97592eb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -13,7 +13,7 @@ fn star_spawning_system(commands: &mut Commands, time: Res<Time>, mut q: Query<&
                 timer.reset();
                 commands
                     .spawn(SpriteSheetBundle {
-                        sprite: TextureAtlasSprite::new(16),
+                        sprite: TextureAtlasSprite::new(constants::TILESHEET_STAR1),
                         transform: Transform {
                             translation: Vec3 {
                                 x: thread_rng().gen_range(-300..300) as f32,
@@ -59,7 +59,7 @@ pub fn setup(
             ..Default::default()
         })
         .spawn(SpriteSheetBundle {
-            sprite: TextureAtlasSprite::new(8),
+            sprite: TextureAtlasSprite::new(constants::TILESHEET_COSMONAUT1),
             texture_atlas: atlas_handle.clone(),
             transform: Transform {
                 translation: Vec3 {
@@ -74,7 +74,7 @@ pub fn setup(
         })
         .spawn((Timer::from_seconds(1.0, false),))
         .spawn(SpriteSheetBundle {
-            sprite: TextureAtlasSprite::new(12),
+            sprite: TextureAtlasSprite::new(constants::TILESHEET_COSMONAUT2),
             texture_atlas: atlas_handle.clone(),
             transform: Transform {
                 translation: Vec3 {
@@ -93,7 +93,7 @@ pub fn setup(
             commands
                 .spawn(SpriteSheetBundle {
                     texture_atlas: atlas_handle.clone(),
-                    sprite: TextureAtlasSprite::new(11),
+                    sprite: TextureAtlasSprite::new(constants::TILESHEET_NONE1),
                     transform: Transform {
                         translation: Vec3 {
                             x: ((i as f32) * 16.0 * 3.5) - 320.0,
@@ -119,16 +119,22 @@ fn animation_system(
         timer.tick(time.delta_seconds());
         if timer.finished() {
             let index = match sprite.index {
-                9 => 10,
-                10 => 13,
-                13 => 14,
-                11 => 12,
-                16 => 17,
-                17 => 18,
-                _ => 11,
+                constants::TILESHEET_EXPLOSION1 => constants::TILESHEET_EXPLOSION2,
+                constants::TILESHEET_EXPLOSION2 => constants::TILESHEET_EXPLOSION3,
+                constants::TILESHEET_EXPLOSION3 => constants::TILESHEET_EXPLOSION4,
+
+                constants::TILESHEET_VISOR1 => constants::TILESHEET_VISOR2,
+                constants::TILESHEET_VISOR2 => constants::TILESHEET_VISOR3,
+                constants::TILESHEET_VISOR3 => constants::TILESHEET_VISOR4,
+
+                constants::TILESHEET_STAR1 => constants::TILESHEET_STAR2,
+                constants::TILESHEET_STAR2 => constants::TILESHEET_STAR3,
+
+                constants::TILESHEET_NONE1 => constants::TILESHEET_NONE2,
+                _ => constants::TILESHEET_NONE1,
             };
             sprite.index = index;
-            if index == 12 {
+            if index == constants::TILESHEET_NONE2 {
                 commands.despawn(entity);
             }
         }
@@ -151,11 +157,11 @@ fn cosmonaut_detect_system(
                 && transform.translation.x + 16.0 * 3.5 > cursor_position.x
                 && transform.translation.y < cursor_position.y
                 && transform.translation.y + 16.0 * 3.5 > cursor_position.y
-                && sprite.index == 8
+                && sprite.index == constants::TILESHEET_COSMONAUT1
             {
                 commands
                     .spawn(SpriteSheetBundle {
-                        sprite: TextureAtlasSprite::new(9),
+                        sprite: TextureAtlasSprite::new(constants::TILESHEET_VISOR1),
                         transform: *transform,
                         ..Default::default()
                     })
-- 
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 ++++-----------------------
 src/main.rs | 21 ++++++++++++++++-----
 2 files changed, 20 insertions(+), 28 deletions(-)

(limited to 'src')

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),));
         }
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 97592eb..164ffe3 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,6 +1,6 @@
 use bevy::math::Vec3;
 use bevy::prelude::*;
-use gems::cell::{self, Cell};
+use gems::cell::{self, Cell, Occupant};
 use gems::constants;
 use rand::{thread_rng, Rng};
 
@@ -113,9 +113,14 @@ pub fn setup(
 fn animation_system(
     commands: &mut Commands,
     time: Res<Time>,
-    mut cell_query: Query<(Entity, &mut Timer, &mut TextureAtlasSprite), Without<Cell>>,
+    mut cell_query: Query<(
+        Entity,
+        Option<&mut Cell>,
+        &mut Timer,
+        &mut TextureAtlasSprite,
+    )>,
 ) {
-    for (entity, mut timer, mut sprite) in cell_query.iter_mut() {
+    for (entity, cell, mut timer, mut sprite) in cell_query.iter_mut() {
         timer.tick(time.delta_seconds());
         if timer.finished() {
             let index = match sprite.index {
@@ -135,7 +140,13 @@ fn animation_system(
             };
             sprite.index = index;
             if index == constants::TILESHEET_NONE2 {
-                commands.despawn(entity);
+                if let Some(mut cell) = cell {
+                    cell.occupant = Occupant::None;
+                    sprite.index = cell.occupant.to_index();
+                    commands.remove_one::<Timer>(entity);
+                } else {
+                    commands.despawn(entity);
+                }
             }
         }
     }
@@ -250,7 +261,7 @@ impl Plugin for GemsPlugin {
         app.add_system(cell::insert.system());
         app.add_system(cell::falling.system());
         app.add_system(cell::check.system());
-        app.add_system(cell::explosion_animation.system());
+        app.add_system(cell::start_explosion.system());
         app.add_system(mouse_system.system());
         app.add_system(cosmonaut_detect_system.system());
         app.add_system(animation_system.system());
-- 
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 +++---
 src/constants.rs | 11 ++++-------
 src/main.rs      | 56 ++++++++++++++++++++++++++++++++++----------------------
 3 files changed, 41 insertions(+), 32 deletions(-)

(limited to 'src')

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));
diff --git a/src/constants.rs b/src/constants.rs
index c33e30b..d8effa8 100644
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -1,11 +1,8 @@
-pub const TILE_SCALE: f32 = 3.0;
+pub const TILE_SCALE: f32 = 3.5;
 pub const TILE_SIZE: f32 = 16.0;
-pub const TILE_WIDTH: f32 = 16.0;
-pub const BORDER_SIZE: f32 = 3.0;
-pub const SHIFT_X: f32 = 50.0;
-pub const SHIFT_Y: f32 = 50.0;
-pub const COLUMNS: usize = 8;
-pub const ROWS: usize = 8;
+pub const WINDOW_HEIGHT: f32 = 600.0;
+pub const WINDOW_WIDTH: f32 = 800.0;
+pub const GRID_SIZE: usize = 8;
 
 pub const TILESHEET_GREEN: u32 = 0;
 pub const TILESHEET_YELLOW: u32 = 1;
diff --git a/src/main.rs b/src/main.rs
index 164ffe3..624aa5b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -40,7 +40,12 @@ pub fn setup(
     let background = asset_server.load("background.png");
     let tileset = asset_server.load("tileset.png");
 
-    let atlas = TextureAtlas::from_grid(tileset, Vec2::new(16.0, 16.0), 4, 5);
+    let atlas = TextureAtlas::from_grid(
+        tileset,
+        Vec2::new(constants::TILE_SIZE, constants::TILE_SIZE),
+        4,
+        5,
+    );
     let atlas_handle = texture_atlases.add(atlas);
 
     commands
@@ -53,7 +58,7 @@ pub fn setup(
                     y: 0.0,
                     z: 0.0,
                 },
-                scale: Vec3::splat(3.5),
+                scale: Vec3::splat(constants::TILE_SCALE),
                 ..Default::default()
             },
             ..Default::default()
@@ -67,7 +72,7 @@ pub fn setup(
                     y: -200.0,
                     z: 0.0,
                 },
-                scale: Vec3::splat(3.5),
+                scale: Vec3::splat(constants::TILE_SCALE),
                 ..Default::default()
             },
             ..Default::default()
@@ -79,28 +84,28 @@ pub fn setup(
             transform: Transform {
                 translation: Vec3 {
                     x: 225.0,
-                    y: -200.0 + (-16.0) * 3.5,
+                    y: -200.0 + (-constants::TILE_SIZE) * constants::TILE_SCALE,
                     z: 0.0,
                 },
-                scale: Vec3::splat(3.5),
+                scale: Vec3::splat(constants::TILE_SCALE),
                 ..Default::default()
             },
             ..Default::default()
         });
 
-    for i in 0..constants::COLUMNS {
-        for j in 0..constants::ROWS {
+    for i in 0..constants::GRID_SIZE {
+        for j in 0..constants::GRID_SIZE {
             commands
                 .spawn(SpriteSheetBundle {
                     texture_atlas: atlas_handle.clone(),
                     sprite: TextureAtlasSprite::new(constants::TILESHEET_NONE1),
                     transform: Transform {
                         translation: Vec3 {
-                            x: ((i as f32) * 16.0 * 3.5) - 320.0,
-                            y: ((j as f32) * 16.0 * 3.5) - 160.0,
+                            x: ((i as f32) * constants::TILE_SIZE * constants::TILE_SCALE) - 320.0,
+                            y: ((j as f32) * constants::TILE_SIZE * constants::TILE_SCALE) - 160.0,
                             z: 1.0,
                         },
-                        scale: Vec3::splat(3.5),
+                        scale: Vec3::splat(constants::TILE_SCALE),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -161,13 +166,17 @@ fn cosmonaut_detect_system(
         .get_primary()
         .and_then(|window| window.cursor_position())
     {
-        cursor_position.x -= 400.0 - 16.0 * 3.5 * 0.5;
-        cursor_position.y -= 300.0 - 16.0 * 3.5 * 0.5;
+        cursor_position.x -=
+            (constants::WINDOW_WIDTH / 2.0) - constants::TILE_SIZE * constants::TILE_SCALE * 0.5;
+        cursor_position.y -=
+            (constants::WINDOW_HEIGHT / 2.0) - constants::TILE_SIZE * constants::TILE_SCALE * 0.5;
         for (transform, sprite) in cell_query.iter_mut() {
             if transform.translation.x < cursor_position.x
-                && transform.translation.x + 16.0 * 3.5 > cursor_position.x
+                && transform.translation.x + constants::TILE_SIZE * constants::TILE_SCALE
+                    > cursor_position.x
                 && transform.translation.y < cursor_position.y
-                && transform.translation.y + 16.0 * 3.5 > cursor_position.y
+                && transform.translation.y + constants::TILE_SIZE * constants::TILE_SCALE
+                    > cursor_position.y
                 && sprite.index == constants::TILESHEET_COSMONAUT1
             {
                 commands
@@ -191,8 +200,10 @@ fn mouse_system(
         .get_primary()
         .and_then(|window| window.cursor_position())
     {
-        cursor_position.x -= 400.0 - 16.0 * 3.5 * 0.5;
-        cursor_position.y -= 300.0 - 16.0 * 3.5 * 0.5;
+        cursor_position.x -=
+            (constants::WINDOW_WIDTH / 2.0) - constants::TILE_SIZE * constants::TILE_SCALE * 0.5;
+        cursor_position.y -=
+            (constants::WINDOW_HEIGHT / 2.0) - constants::TILE_SIZE * constants::TILE_SCALE * 0.5;
 
         for (cell, _, mut sprite) in cell_query.iter_mut() {
             if cell.selected {
@@ -204,14 +215,15 @@ fn mouse_system(
             }
         }
 
-        for (mut cell, transform, mut sprite) in cell_query.iter_mut() {
+        for (mut cell, transform, _) in cell_query.iter_mut() {
             if transform.translation.x < cursor_position.x
-                && transform.translation.x + 16.0 * 3.5 > cursor_position.x
+                && transform.translation.x + constants::TILE_SIZE * constants::TILE_SCALE
+                    > cursor_position.x
                 && transform.translation.y < cursor_position.y
-                && transform.translation.y + 16.0 * 3.5 > cursor_position.y
+                && transform.translation.y + constants::TILE_SIZE * constants::TILE_SCALE
+                    > cursor_position.y
             {
                 cell.hovered = true;
-                sprite.color.set_a(0.5);
                 if mouse_button_input.just_pressed(MouseButton::Left) {
                     cell.selected = true;
                 }
@@ -273,8 +285,8 @@ pub fn main() {
     App::build()
         .add_resource(WindowDescriptor {
             title: "gems".to_string(),
-            width: 800.0,
-            height: 600.0,
+            width: constants::WINDOW_WIDTH,
+            height: constants::WINDOW_HEIGHT,
             resizable: false,
             ..Default::default()
         })
-- 
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 ++++++++++++---------------
 src/main.rs | 20 ++++++++++----------
 2 files changed, 22 insertions(+), 25 deletions(-)

(limited to 'src')

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();
diff --git a/src/main.rs b/src/main.rs
index 624aa5b..79c0f2b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -118,14 +118,14 @@ pub fn setup(
 fn animation_system(
     commands: &mut Commands,
     time: Res<Time>,
-    mut cell_query: Query<(
+    mut q: Query<(
         Entity,
         Option<&mut Cell>,
         &mut Timer,
         &mut TextureAtlasSprite,
     )>,
 ) {
-    for (entity, cell, mut timer, mut sprite) in cell_query.iter_mut() {
+    for (entity, cell, mut timer, mut sprite) in q.iter_mut() {
         timer.tick(time.delta_seconds());
         if timer.finished() {
             let index = match sprite.index {
@@ -160,7 +160,7 @@ fn animation_system(
 fn cosmonaut_detect_system(
     commands: &mut Commands,
     windows: Res<Windows>,
-    mut cell_query: Query<(&Transform, &TextureAtlasSprite)>,
+    mut q: Query<(&Transform, &TextureAtlasSprite)>,
 ) {
     if let Some(mut cursor_position) = windows
         .get_primary()
@@ -170,7 +170,7 @@ fn cosmonaut_detect_system(
             (constants::WINDOW_WIDTH / 2.0) - constants::TILE_SIZE * constants::TILE_SCALE * 0.5;
         cursor_position.y -=
             (constants::WINDOW_HEIGHT / 2.0) - constants::TILE_SIZE * constants::TILE_SCALE * 0.5;
-        for (transform, sprite) in cell_query.iter_mut() {
+        for (transform, sprite) in q.iter_mut() {
             if transform.translation.x < cursor_position.x
                 && transform.translation.x + constants::TILE_SIZE * constants::TILE_SCALE
                     > cursor_position.x
@@ -193,7 +193,7 @@ fn cosmonaut_detect_system(
 
 fn mouse_system(
     windows: Res<Windows>,
-    mut cell_query: Query<(&mut Cell, &mut Transform, &mut TextureAtlasSprite)>,
+    mut q: Query<(&mut Cell, &mut Transform, &mut TextureAtlasSprite)>,
     mouse_button_input: Res<Input<MouseButton>>,
 ) {
     if let Some(mut cursor_position) = windows
@@ -205,7 +205,7 @@ fn mouse_system(
         cursor_position.y -=
             (constants::WINDOW_HEIGHT / 2.0) - constants::TILE_SIZE * constants::TILE_SCALE * 0.5;
 
-        for (cell, _, mut sprite) in cell_query.iter_mut() {
+        for (cell, _, mut sprite) in q.iter_mut() {
             if cell.selected {
                 sprite.color.set_a(0.2);
             } else if cell.hovered {
@@ -215,7 +215,7 @@ fn mouse_system(
             }
         }
 
-        for (mut cell, transform, _) in cell_query.iter_mut() {
+        for (mut cell, transform, _) in q.iter_mut() {
             if transform.translation.x < cursor_position.x
                 && transform.translation.x + constants::TILE_SIZE * constants::TILE_SCALE
                     > cursor_position.x
@@ -234,7 +234,7 @@ fn mouse_system(
 
         if mouse_button_input.just_released(MouseButton::Left) {
             let mut cells: Vec<Cell> = Vec::new();
-            for (cell, _, _) in cell_query.iter_mut() {
+            for (cell, _, _) in q.iter_mut() {
                 cells.push(*cell);
             }
             if let Some(mut selected) = cells.clone().iter_mut().find(|c| c.selected) {
@@ -247,7 +247,7 @@ fn mouse_system(
                         let tmp = selected.occupant;
                         selected.occupant = hovered.occupant;
                         hovered.occupant = tmp;
-                        for (mut cell, _, mut sprite) in cell_query.iter_mut() {
+                        for (mut cell, _, mut sprite) in q.iter_mut() {
                             if cell.x == selected.x && cell.y == selected.y {
                                 cell.occupant = selected.occupant;
                                 sprite.index = cell.occupant.to_index();
@@ -259,7 +259,7 @@ fn mouse_system(
                     }
                 }
             }
-            for (mut cell, _, _) in cell_query.iter_mut() {
+            for (mut cell, _, _) in q.iter_mut() {
                 cell.selected = false;
             }
         }
-- 
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')

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 ++-
 src/main.rs | 141 +++++++++++++++++++++++++++++-------------------------------
 2 files changed, 72 insertions(+), 75 deletions(-)

(limited to 'src')

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));
         }
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 79c0f2b..1c1d49a 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,36 +3,38 @@ use bevy::prelude::*;
 use gems::cell::{self, Cell, Occupant};
 use gems::constants;
 use rand::{thread_rng, Rng};
+use std::time::Duration;
 
-fn star_spawning_system(commands: &mut Commands, time: Res<Time>, mut q: Query<&mut Timer>) {
+fn star_spawning_system(mut commands: Commands, time: Res<Time>, mut q: Query<&mut Timer>) {
     for mut timer in q.iter_mut() {
         if !timer.repeating() {
-            timer.tick(time.delta_seconds());
+            timer.tick(time.delta());
             if timer.just_finished() {
-                timer.set_duration(thread_rng().gen_range(2..5) as f32);
+                timer.set_duration(Duration::new(thread_rng().gen_range(2..5), 0));
                 timer.reset();
-                commands
-                    .spawn(SpriteSheetBundle {
+                commands.spawn_bundle((
+                    SpriteSheetBundle {
                         sprite: TextureAtlasSprite::new(constants::TILESHEET_STAR1),
                         transform: Transform {
-                            translation: Vec3 {
-                                x: thread_rng().gen_range(-300..300) as f32,
-                                y: thread_rng().gen_range(-200..300) as f32,
-                                z: 0.0,
-                            },
+                            translation: Vec3::new(
+                                thread_rng().gen_range(-300..300) as f32,
+                                thread_rng().gen_range(-200..300) as f32,
+                                0.0,
+                            ),
                             scale: Vec3::splat(thread_rng().gen_range(1..3) as f32),
                             ..Default::default()
                         },
                         ..Default::default()
-                    })
-                    .with(Timer::from_seconds(0.25, true));
+                    },
+                    Timer::from_seconds(0.25, true),
+                ));
             }
         }
     }
 }
 
 pub fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
     mut texture_atlases: ResMut<Assets<TextureAtlas>>,
@@ -48,75 +50,67 @@ pub fn setup(
     );
     let atlas_handle = texture_atlases.add(atlas);
 
-    commands
-        .spawn(Camera2dBundle::default())
-        .spawn(SpriteBundle {
-            material: materials.add(background.into()),
-            transform: Transform {
-                translation: Vec3 {
-                    x: 50.0,
-                    y: 0.0,
-                    z: 0.0,
-                },
-                scale: Vec3::splat(constants::TILE_SCALE),
-                ..Default::default()
-            },
+    commands.spawn_bundle(OrthographicCameraBundle::new_2d());
+    commands.spawn_bundle(SpriteBundle {
+        material: materials.add(background.into()),
+        transform: Transform {
+            translation: Vec3::new(50.0, 0.0, 0.0),
+            scale: Vec3::splat(constants::TILE_SCALE),
             ..Default::default()
-        })
-        .spawn(SpriteSheetBundle {
-            sprite: TextureAtlasSprite::new(constants::TILESHEET_COSMONAUT1),
-            texture_atlas: atlas_handle.clone(),
-            transform: Transform {
-                translation: Vec3 {
-                    x: 225.0,
-                    y: -200.0,
-                    z: 0.0,
-                },
-                scale: Vec3::splat(constants::TILE_SCALE),
-                ..Default::default()
-            },
+        },
+        ..Default::default()
+    });
+    commands.spawn_bundle(SpriteSheetBundle {
+        sprite: TextureAtlasSprite::new(constants::TILESHEET_COSMONAUT1),
+        texture_atlas: atlas_handle.clone(),
+        transform: Transform {
+            translation: Vec3::new(225.0, -200.0, 0.0),
+            scale: Vec3::splat(constants::TILE_SCALE),
             ..Default::default()
-        })
-        .spawn((Timer::from_seconds(1.0, false),))
-        .spawn(SpriteSheetBundle {
-            sprite: TextureAtlasSprite::new(constants::TILESHEET_COSMONAUT2),
-            texture_atlas: atlas_handle.clone(),
-            transform: Transform {
-                translation: Vec3 {
-                    x: 225.0,
-                    y: -200.0 + (-constants::TILE_SIZE) * constants::TILE_SCALE,
-                    z: 0.0,
-                },
-                scale: Vec3::splat(constants::TILE_SCALE),
-                ..Default::default()
-            },
+        },
+        ..Default::default()
+    });
+    commands.spawn_bundle((Timer::from_seconds(1.0, false),));
+    commands.spawn_bundle(SpriteSheetBundle {
+        sprite: TextureAtlasSprite::new(constants::TILESHEET_COSMONAUT2),
+        texture_atlas: atlas_handle.clone(),
+        transform: Transform {
+            translation: Vec3::new(
+                225.0,
+                -200.0 + (-constants::TILE_SIZE) * constants::TILE_SCALE,
+                0.0,
+            ),
+            scale: Vec3::splat(constants::TILE_SCALE),
             ..Default::default()
-        });
+        },
+        ..Default::default()
+    });
 
     for i in 0..constants::GRID_SIZE {
         for j in 0..constants::GRID_SIZE {
-            commands
-                .spawn(SpriteSheetBundle {
+            commands.spawn_bundle((
+                SpriteSheetBundle {
                     texture_atlas: atlas_handle.clone(),
                     sprite: TextureAtlasSprite::new(constants::TILESHEET_NONE1),
                     transform: Transform {
-                        translation: Vec3 {
-                            x: ((i as f32) * constants::TILE_SIZE * constants::TILE_SCALE) - 320.0,
-                            y: ((j as f32) * constants::TILE_SIZE * constants::TILE_SCALE) - 160.0,
-                            z: 1.0,
-                        },
+                        translation: Vec3::new(
+                            ((i as f32) * constants::TILE_SIZE * constants::TILE_SCALE) - 320.0,
+                            ((j as f32) * constants::TILE_SIZE * constants::TILE_SCALE) - 160.0,
+                            1.0,
+                        ),
                         scale: Vec3::splat(constants::TILE_SCALE),
                         ..Default::default()
                     },
                     ..Default::default()
-                })
-                .with(Cell::new(i, j));
+                },
+                Cell::new(i, j),
+            ));
         }
     }
 }
 
 fn animation_system(
-    commands: &mut Commands,
+    mut commands: Commands,
     time: Res<Time>,
     mut q: Query<(
         Entity,
@@ -126,7 +120,7 @@ fn animation_system(
     )>,
 ) {
     for (entity, cell, mut timer, mut sprite) in q.iter_mut() {
-        timer.tick(time.delta_seconds());
+        timer.tick(time.delta());
         if timer.finished() {
             let index = match sprite.index {
                 constants::TILESHEET_EXPLOSION1 => constants::TILESHEET_EXPLOSION2,
@@ -148,9 +142,9 @@ fn animation_system(
                 if let Some(mut cell) = cell {
                     cell.occupant = Occupant::None;
                     sprite.index = cell.occupant.to_index();
-                    commands.remove_one::<Timer>(entity);
+                    commands.entity(entity).remove::<Timer>();
                 } else {
-                    commands.despawn(entity);
+                    commands.entity(entity).despawn();
                 }
             }
         }
@@ -158,7 +152,7 @@ fn animation_system(
 }
 
 fn cosmonaut_detect_system(
-    commands: &mut Commands,
+    mut commands: Commands,
     windows: Res<Windows>,
     mut q: Query<(&Transform, &TextureAtlasSprite)>,
 ) {
@@ -179,13 +173,14 @@ fn cosmonaut_detect_system(
                     > cursor_position.y
                 && sprite.index == constants::TILESHEET_COSMONAUT1
             {
-                commands
-                    .spawn(SpriteSheetBundle {
+                commands.spawn_bundle((
+                    SpriteSheetBundle {
                         sprite: TextureAtlasSprite::new(constants::TILESHEET_VISOR1),
                         transform: *transform,
                         ..Default::default()
-                    })
-                    .with(Timer::from_seconds(0.1, true));
+                    },
+                    Timer::from_seconds(0.1, true),
+                ));
             }
         }
     }
@@ -283,7 +278,7 @@ impl Plugin for GemsPlugin {
 
 pub fn main() {
     App::build()
-        .add_resource(WindowDescriptor {
+        .insert_resource(WindowDescriptor {
             title: "gems".to_string(),
             width: constants::WINDOW_WIDTH,
             height: constants::WINDOW_HEIGHT,
-- 
cgit v1.2.3


From 009145e86988274584012e6d37da46357cd3cea3 Mon Sep 17 00:00:00 2001
From: Tom Barrett <tom@tombarrett.xyz>
Date: Sun, 4 Apr 2021 14:41:26 +0200
Subject: spawn_bundles doesn't work as expected?

---
 src/main.rs | 43 ++++++++++++++++++++-----------------------
 1 file changed, 20 insertions(+), 23 deletions(-)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index 1c1d49a..b73c54a 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,15 +5,15 @@ use gems::constants;
 use rand::{thread_rng, Rng};
 use std::time::Duration;
 
-fn star_spawning_system(mut commands: Commands, time: Res<Time>, mut q: Query<&mut Timer>) {
+fn star_spawning(mut commands: Commands, time: Res<Time>, mut q: Query<&mut Timer>) {
     for mut timer in q.iter_mut() {
         if !timer.repeating() {
             timer.tick(time.delta());
             if timer.just_finished() {
                 timer.set_duration(Duration::new(thread_rng().gen_range(2..5), 0));
                 timer.reset();
-                commands.spawn_bundle((
-                    SpriteSheetBundle {
+                commands
+                    .spawn_bundle(SpriteSheetBundle {
                         sprite: TextureAtlasSprite::new(constants::TILESHEET_STAR1),
                         transform: Transform {
                             translation: Vec3::new(
@@ -25,9 +25,8 @@ fn star_spawning_system(mut commands: Commands, time: Res<Time>, mut q: Query<&m
                             ..Default::default()
                         },
                         ..Default::default()
-                    },
-                    Timer::from_seconds(0.25, true),
-                ));
+                    })
+                    .insert(Timer::from_seconds(0.25, true));
             }
         }
     }
@@ -88,8 +87,8 @@ pub fn setup(
 
     for i in 0..constants::GRID_SIZE {
         for j in 0..constants::GRID_SIZE {
-            commands.spawn_bundle((
-                SpriteSheetBundle {
+            commands
+                .spawn_bundle(SpriteSheetBundle {
                     texture_atlas: atlas_handle.clone(),
                     sprite: TextureAtlasSprite::new(constants::TILESHEET_NONE1),
                     transform: Transform {
@@ -102,14 +101,13 @@ pub fn setup(
                         ..Default::default()
                     },
                     ..Default::default()
-                },
-                Cell::new(i, j),
-            ));
+                })
+                .insert(Cell::new(i, j));
         }
     }
 }
 
-fn animation_system(
+fn animation(
     mut commands: Commands,
     time: Res<Time>,
     mut q: Query<(
@@ -151,7 +149,7 @@ fn animation_system(
     }
 }
 
-fn cosmonaut_detect_system(
+fn cosmonaut_detect(
     mut commands: Commands,
     windows: Res<Windows>,
     mut q: Query<(&Transform, &TextureAtlasSprite)>,
@@ -173,20 +171,19 @@ fn cosmonaut_detect_system(
                     > cursor_position.y
                 && sprite.index == constants::TILESHEET_COSMONAUT1
             {
-                commands.spawn_bundle((
-                    SpriteSheetBundle {
+                commands
+                    .spawn_bundle(SpriteSheetBundle {
                         sprite: TextureAtlasSprite::new(constants::TILESHEET_VISOR1),
                         transform: *transform,
                         ..Default::default()
-                    },
-                    Timer::from_seconds(0.1, true),
-                ));
+                    })
+                    .insert(Timer::from_seconds(0.1, true));
             }
         }
     }
 }
 
-fn mouse_system(
+fn mouse(
     windows: Res<Windows>,
     mut q: Query<(&mut Cell, &mut Transform, &mut TextureAtlasSprite)>,
     mouse_button_input: Res<Input<MouseButton>>,
@@ -269,10 +266,10 @@ impl Plugin for GemsPlugin {
         app.add_system(cell::falling.system());
         app.add_system(cell::check.system());
         app.add_system(cell::start_explosion.system());
-        app.add_system(mouse_system.system());
-        app.add_system(cosmonaut_detect_system.system());
-        app.add_system(animation_system.system());
-        app.add_system(star_spawning_system.system());
+        app.add_system(mouse.system());
+        app.add_system(cosmonaut_detect.system());
+        app.add_system(animation.system());
+        app.add_system(star_spawning.system());
     }
 }
 
-- 
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 ++++-
 src/constants.rs | 45 +++++++++++++++++++++++++--------------------
 src/main.rs      | 14 ++++++++++++--
 3 files changed, 41 insertions(+), 23 deletions(-)

(limited to 'src')

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,
         }
     }
diff --git a/src/constants.rs b/src/constants.rs
index d8effa8..7eed139 100644
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -4,27 +4,32 @@ pub const WINDOW_HEIGHT: f32 = 600.0;
 pub const WINDOW_WIDTH: f32 = 800.0;
 pub const GRID_SIZE: usize = 8;
 
-pub const TILESHEET_GREEN: u32 = 0;
-pub const TILESHEET_YELLOW: u32 = 1;
-pub const TILESHEET_BLUE: u32 = 2;
-pub const TILESHEET_RED: u32 = 3;
+pub const TILESHEET_EXPLOSION1: u32 = 0;
+pub const TILESHEET_EXPLOSION2: u32 = 1;
+pub const TILESHEET_EXPLOSION3: u32 = 2;
+pub const TILESHEET_EXPLOSION4: u32 = 3;
+pub const TILESHEET_EXPLOSION5: u32 = 4;
 
-pub const TILESHEET_EXPLOSION1: u32 = 4;
-pub const TILESHEET_EXPLOSION2: u32 = 5;
-pub const TILESHEET_EXPLOSION3: u32 = 6;
-pub const TILESHEET_EXPLOSION4: u32 = 7;
+pub const TILESHEET_GREEN: u32 = 5;
+pub const TILESHEET_YELLOW: u32 = 6;
+pub const TILESHEET_BLUE: u32 = 7;
+pub const TILESHEET_RED: u32 = 8;
+pub const TILESHEET_PURPLE: u32 = 9;
 
-pub const TILESHEET_COSMONAUT1: u32 = 8;
-pub const TILESHEET_VISOR1: u32 = 9;
-pub const TILESHEET_VISOR2: u32 = 10;
-pub const TILESHEET_NONE1: u32 = 11;
+pub const TILESHEET_STAR1: u32 = 10;
+pub const TILESHEET_STAR2: u32 = 11;
+pub const TILESHEET_STAR3: u32 = 12;
+pub const TILESHEET_NONE1: u32 = 13;
+pub const TILESHEET_NONE2: u32 = 14;
 
-pub const TILESHEET_COSMONAUT2: u32 = 12;
-pub const TILESHEET_VISOR3: u32 = 13;
-pub const TILESHEET_VISOR4: u32 = 14;
-pub const TILESHEET_NONE2: u32 = 15;
+pub const TILESHEET_COSMONAUT1: u32 = 15;
+pub const TILESHEET_VISOR1: u32 = 16;
+pub const TILESHEET_VISOR2: u32 = 17;
+pub const TILESHEET_NONE3: u32 = 18;
+pub const TILESHEET_NONE4: u32 = 19;
 
-pub const TILESHEET_STAR1: u32 = 16;
-pub const TILESHEET_STAR2: u32 = 17;
-pub const TILESHEET_STAR3: u32 = 18;
-pub const TILESHEET_NONE3: u32 = 19;
+pub const TILESHEET_COSMONAUT2: u32 = 20;
+pub const TILESHEET_VISOR3: u32 = 21;
+pub const TILESHEET_VISOR4: u32 = 22;
+pub const TILESHEET_NONE6: u32 = 23;
+pub const TILESHEET_NONE7: u32 = 24;
diff --git a/src/main.rs b/src/main.rs
index b73c54a..8a59000 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -40,11 +40,12 @@ pub fn setup(
 ) {
     let background = asset_server.load("background.png");
     let tileset = asset_server.load("tileset.png");
+    let title = asset_server.load("title.png");
 
     let atlas = TextureAtlas::from_grid(
         tileset,
         Vec2::new(constants::TILE_SIZE, constants::TILE_SIZE),
-        4,
+        5,
         5,
     );
     let atlas_handle = texture_atlases.add(atlas);
@@ -59,6 +60,15 @@ pub fn setup(
         },
         ..Default::default()
     });
+    commands.spawn_bundle(SpriteBundle {
+        material: materials.add(title.into()),
+        transform: Transform {
+            translation: Vec3::new(240.0, 200.0, 0.0),
+            scale: Vec3::splat(2.0),
+            ..Default::default()
+        },
+        ..Default::default()
+    });
     commands.spawn_bundle(SpriteSheetBundle {
         sprite: TextureAtlasSprite::new(constants::TILESHEET_COSMONAUT1),
         texture_atlas: atlas_handle.clone(),
@@ -93,7 +103,7 @@ pub fn setup(
                     sprite: TextureAtlasSprite::new(constants::TILESHEET_NONE1),
                     transform: Transform {
                         translation: Vec3::new(
-                            ((i as f32) * constants::TILE_SIZE * constants::TILE_SCALE) - 320.0,
+                            ((i as f32) * constants::TILE_SIZE * constants::TILE_SCALE) - 330.0,
                             ((j as f32) * constants::TILE_SIZE * constants::TILE_SCALE) - 160.0,
                             1.0,
                         ),
-- 
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 +++++++++++++++++++++++++++++------------------
 src/constants.rs | 12 ++++++------
 src/main.rs      | 45 ++++++++++++++++++++++++---------------------
 3 files changed, 59 insertions(+), 45 deletions(-)

(limited to 'src')

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);
         }
     }
 }
diff --git a/src/constants.rs b/src/constants.rs
index 7eed139..86bbe5e 100644
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -19,17 +19,17 @@ pub const TILESHEET_PURPLE: u32 = 9;
 pub const TILESHEET_STAR1: u32 = 10;
 pub const TILESHEET_STAR2: u32 = 11;
 pub const TILESHEET_STAR3: u32 = 12;
-pub const TILESHEET_NONE1: u32 = 13;
-pub const TILESHEET_NONE2: u32 = 14;
+//pub const TILESHEET_X: u32 = 13;
+//pub const TILESHEET_X: u32 = 14;
 
 pub const TILESHEET_COSMONAUT1: u32 = 15;
 pub const TILESHEET_VISOR1: u32 = 16;
 pub const TILESHEET_VISOR2: u32 = 17;
-pub const TILESHEET_NONE3: u32 = 18;
-pub const TILESHEET_NONE4: u32 = 19;
+//pub const TILESHEET_X: u32 = 18;
+//pub const TILESHEET_X: u32 = 19;
 
 pub const TILESHEET_COSMONAUT2: u32 = 20;
 pub const TILESHEET_VISOR3: u32 = 21;
 pub const TILESHEET_VISOR4: u32 = 22;
-pub const TILESHEET_NONE6: u32 = 23;
-pub const TILESHEET_NONE7: u32 = 24;
+//pub const TILESHEET_X: u32 = 23;
+//pub const TILESHEET_X: u32 = 24;
diff --git a/src/main.rs b/src/main.rs
index 8a59000..c69d791 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -100,7 +100,10 @@ pub fn setup(
             commands
                 .spawn_bundle(SpriteSheetBundle {
                     texture_atlas: atlas_handle.clone(),
-                    sprite: TextureAtlasSprite::new(constants::TILESHEET_NONE1),
+                    visible: Visible {
+                        is_visible: false,
+                        is_transparent: true,
+                    },
                     transform: Transform {
                         translation: Vec3::new(
                             ((i as f32) * constants::TILE_SIZE * constants::TILE_SCALE) - 330.0,
@@ -125,35 +128,35 @@ fn animation(
         Option<&mut Cell>,
         &mut Timer,
         &mut TextureAtlasSprite,
+        &mut Visible,
     )>,
 ) {
-    for (entity, cell, mut timer, mut sprite) in q.iter_mut() {
+    for (entity, cell, mut timer, mut sprite, mut visible) in q.iter_mut() {
         timer.tick(time.delta());
         if timer.finished() {
             let index = match sprite.index {
-                constants::TILESHEET_EXPLOSION1 => constants::TILESHEET_EXPLOSION2,
-                constants::TILESHEET_EXPLOSION2 => constants::TILESHEET_EXPLOSION3,
-                constants::TILESHEET_EXPLOSION3 => constants::TILESHEET_EXPLOSION4,
+                constants::TILESHEET_EXPLOSION1 => Some(constants::TILESHEET_EXPLOSION2),
+                constants::TILESHEET_EXPLOSION2 => Some(constants::TILESHEET_EXPLOSION3),
+                constants::TILESHEET_EXPLOSION3 => Some(constants::TILESHEET_EXPLOSION4),
+                constants::TILESHEET_EXPLOSION4 => Some(constants::TILESHEET_EXPLOSION5),
 
-                constants::TILESHEET_VISOR1 => constants::TILESHEET_VISOR2,
-                constants::TILESHEET_VISOR2 => constants::TILESHEET_VISOR3,
-                constants::TILESHEET_VISOR3 => constants::TILESHEET_VISOR4,
+                constants::TILESHEET_VISOR1 => Some(constants::TILESHEET_VISOR2),
+                constants::TILESHEET_VISOR2 => Some(constants::TILESHEET_VISOR3),
+                constants::TILESHEET_VISOR3 => Some(constants::TILESHEET_VISOR4),
 
-                constants::TILESHEET_STAR1 => constants::TILESHEET_STAR2,
-                constants::TILESHEET_STAR2 => constants::TILESHEET_STAR3,
+                constants::TILESHEET_STAR1 => Some(constants::TILESHEET_STAR2),
+                constants::TILESHEET_STAR2 => Some(constants::TILESHEET_STAR3),
 
-                constants::TILESHEET_NONE1 => constants::TILESHEET_NONE2,
-                _ => constants::TILESHEET_NONE1,
+                _ => None,
             };
-            sprite.index = index;
-            if index == constants::TILESHEET_NONE2 {
-                if let Some(mut cell) = cell {
-                    cell.occupant = Occupant::None;
-                    sprite.index = cell.occupant.to_index();
-                    commands.entity(entity).remove::<Timer>();
-                } else {
-                    commands.entity(entity).despawn();
-                }
+
+            if let Some(index) = index {
+                sprite.index = index;
+            } else if let Some(mut cell) = cell {
+                cell.set_occupant(Occupant::None, &mut sprite, &mut visible);
+                commands.entity(entity).remove::<Timer>();
+            } else {
+                commands.entity(entity).despawn();
             }
         }
     }
-- 
cgit v1.2.3