bestagon 0.9.0

An engine for discrete stuff in hexagonal grids
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use std::hash::Hash;

#[cfg(feature = "bevy")]
use bevy_ecs::prelude::Component;
#[cfg(feature = "bevy")]
use bevy_reflect::Reflect;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

/// A node is shared by three edges, and by three hexes. It is the point that
/// connects them.
pub trait Node: Into<NodeAx> + From<NodeAx> + Hash + Eq + Copy {}

#[derive(Eq, PartialEq, Debug, Copy, Clone, Hash, Default)]
#[cfg_attr(feature = "bevy", derive(Reflect, Component))]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct NodeAx {
  pub q: isize,
  pub r: isize,
}

impl NodeAx {
  pub fn new(q: isize, r: isize) -> Self {
    NodeAx { q, r }
  }
}

impl Node for NodeAx {}

#[derive(PartialEq, Debug, Copy, Clone, Default)]
#[cfg_attr(feature = "bevy", derive(Reflect, Component))]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct FNodeAx {
  pub q: f32,
  pub r: f32,
}

impl FNodeAx {
  pub fn new(q: f32, r: f32) -> Self {
    FNodeAx { q, r }
  }
}

impl From<&NodeAx> for FNodeAx {
  fn from(value: &NodeAx) -> Self {
    FNodeAx::new(value.q as f32, value.r as f32)
  }
}

#[cfg(test)]
mod test {
  use super::*;
  use crate::{edge::*, hex::*, hex_range::*, neighbours::*};
  use std::collections::HashSet;

  #[test]
  fn neighbouring_edges_share_node_cases() {
    for hex in HexRange::sphere(&HexAx::new(0, 0), 2).compute::<HexAx>() {
      for e in hex.edges() {
        verify_neighbouring_edge_share_node(&e);
      }
    }
  }

  fn verify_neighbouring_edge_share_node(e: &EdgeAx) {
    let my_nodes = e.nodes().into_iter().collect::<HashSet<NodeAx>>();
    for n in e.edges() {
      assert_eq!(
        my_nodes
          .intersection(&n.nodes().collect::<HashSet<NodeAx>>())
          .collect::<HashSet<&NodeAx>>()
          .len(),
        1
      );
    }
  }

  #[test]
  fn hex_has_6_nodes_which_each_have_3_hexes_including_the_aforementioned_hex() {
    for hex in HexRange::sphere(&HexAx::new(0, 0), 3).compute::<HexAx>() {
      let nodes = hex.nodes();
      assert_eq!(nodes.count(), 6);
      for node in hex.nodes() {
        let hexes: HashSet<HexAx> = node.hexes().collect();
        assert_eq!(hexes.len(), 3);
        assert!(hexes.contains(&hex));
      }
    }
  }

  #[test]
  fn hex_nodes_each_touch_2_edges_that_touch_the_aforementioned_hex() {
    for hex in HexRange::sphere(&HexAx::new(0, 0), 3).compute::<HexAx>() {
      let hex_edges: HashSet<EdgeAx> = hex.edges().collect();
      let nodes = hex.nodes();
      for node in nodes {
        let edges: HashSet<EdgeAx> = node.edges().collect();
        assert_eq!(edges.len(), 3);
        assert_eq!(
          edges
            .intersection(&hex_edges)
            .collect::<HashSet<&EdgeAx>>()
            .len(),
          2
        );
      }
    }
  }
}