Fix #7. Queen and bishop now move like they should.

Problem was that the diagonal move making did not work like it should at all. To fix this the struct RadialDiagonal was created

Author: confusinguser

src/cell.rs

@@ -4,7 +4,7 @@ use std::ops::{Index, IndexMut};
 use bevy::prelude::*;
 
 use crate::gamemanager::Palette;
-use crate::utils::{self, CartesianDirection, RadialDirection};
+use crate::utils::{self, CartesianDirection, RadialDiagonal, RadialDirection};
 
 #[derive(Clone, Debug)]
 pub(crate) struct Cell {
@@ -85,7 +85,7 @@ impl CellCoordinates {
     /// than the first
     pub(crate) fn get_cell_in_direction(
         &self,
-        direction: utils::CartesianDirection,
+        direction: CartesianDirection,
         cube_side_length: u32,
     ) -> Option<(CellCoordinates, bool)> {
         let normal = self.normal_direction();
@@ -140,6 +140,8 @@ impl CellCoordinates {
         Some((adjacent, folded_to_other_face))
     }
 
+    /// Returns a tuple where the second element denotes if the new cell is on a different side
+    /// than the first
     pub(crate) fn get_cell_in_radial_direction(
         &self,
         radial_direction: RadialDirection,
@@ -159,8 +161,7 @@ impl CellCoordinates {
     }
 
     /// Gets the diagonal that can be reached by walking in the cartesian directions consecutively,
-    /// does not return true neighbors. The second element of the second element denotes if the new
-    /// cell is on a different side than the first
+    /// does not return true neighbors. The second element of the returned tuple denotes if the move crosses an edge
     pub(crate) fn get_diagonal(
         &self,
         diagonal: (CartesianDirection, CartesianDirection),
@@ -179,6 +180,36 @@ impl CellCoordinates {
         Some((cell2.0, cell1.1 || cell2.1))
     }
 
+    /// Gets the diagonal that can be reached by walking in the radial directions consecutively,
+    /// does not return true neighbors. The second element of the returned tuple denotes if the move crosses an edge
+    pub(crate) fn get_diagonal_radial(
+        &self,
+        diagonal: RadialDiagonal,
+        cube_side_length: u32,
+    ) -> Option<(CellCoordinates, bool)> {
+        let mut directions = Vec::new();
+        if self.x != 0 {
+            directions.push(CartesianDirection::from_axis_num(0, diagonal.0));
+        }
+        if self.y != 0 {
+            directions.push(CartesianDirection::from_axis_num(1, diagonal.1));
+        }
+        if self.z != 0 {
+            directions.push(CartesianDirection::from_axis_num(2, diagonal.2));
+        }
+
+        let Some(dir1) = directions.get(0) else {
+            error!("Directions vector is not large enough in get_diagonal_radial. This should not happen.");
+            return None;
+        };
+        let Some(dir2) = directions.get(1) else {
+            error!("Directions vector is not large enough in get_diagonal_radial. This should not happen.");
+            return None;
+        };
+        let directions = (*dir1, *dir2);
+        
+        self.get_diagonal(directions, cube_side_length)
+    }
     pub(crate) fn normal_direction(&self) -> CartesianDirection {
         if self.z == 0 {
             if self.normal_is_positive {

src/cube_rotation.rs

@@ -121,8 +121,6 @@ pub(crate) fn iterate(
 
     input_handling(input, rotation_data);
 
-    dbg!(&rotation_data);
-
     // Apply the rotation
     for mut camera in &mut query {
         let mut transform = camera.0;

src/movement.rs

@@ -161,7 +161,7 @@ mod parts {
 
     use crate::cell::{Board, CellCoordinates};
     use crate::units::Units;
-    use crate::utils::{CartesianDirection, RadialDirection};
+    use crate::utils::{RadialDiagonal, RadialDirection};
 
     pub(crate) fn get_straight(
         coords: CellCoordinates,
@@ -231,35 +231,38 @@ mod parts {
         units: &Units,
     ) -> Vec<CellCoordinates> {
         let mut output = Vec::new();
-        for diagonal in CartesianDirection::diagonals() {
+        for diagonal in RadialDiagonal::diagonals() {
             let mut latest_cell = coords;
             let mut dist = 0;
             let mut edge_crossings = 0;
             loop {
-                let Some(next_cell) = latest_cell.get_diagonal(diagonal, cube_side_length) else {
+                let Some((next_cell, move_crosses_edge)) =
+                    latest_cell.get_diagonal_radial(diagonal, cube_side_length)
+                else {
                     break;
                 };
 
-                if output.iter().any(|cell| *cell == next_cell.0) {
+                // Check for loops
+                if output.iter().any(|cell| *cell == next_cell) {
                     break;
                 }
 
                 dist += 1;
-                if next_cell.1 {
+                if move_crosses_edge {
                     edge_crossings += 1;
                 }
 
                 if dist > max_dist || edge_crossings > max_edge_crossings {
                     break;
                 }
 
-                output.push(next_cell.0);
+                output.push(next_cell);
 
-                if units.is_unit_at(next_cell.0) {
+                if units.is_unit_at(next_cell) {
                     break;
                 }
 
-                latest_cell = next_cell.0;
+                latest_cell = next_cell;
             }
         }
         output

src/utils.rs

@@ -28,6 +28,7 @@ pub(crate) fn first_nonzero_component(v: Vec3) -> Option<u32> {
     None
 }
 
+/// Returns the indices of the components that are non-zero
 pub(crate) fn nonzero_components(v: Vec3) -> Vec<u32> {
     let mut output = Vec::new();
     for i in 0..3 {
@@ -38,6 +39,24 @@ pub(crate) fn nonzero_components(v: Vec3) -> Vec<u32> {
     output
 }
 
+/// Used to represent a diagonal in the cube. The three booleans represent the diagonal axis
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct RadialDiagonal(pub(crate) bool, pub(crate) bool, pub(crate) bool);
+
+impl RadialDiagonal {
+    pub(crate) fn diagonals() -> Vec<RadialDiagonal> {
+        let mut out = Vec::new();
+        for i in [false, true] {
+            for j in [false, true] {
+                for k in [false, true] {
+                    out.push(Self(i, j, k));
+                }
+            }
+        }
+        out
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub(crate) enum RadialDirection {
     ClockwiseX,