bestagon 0.7.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

use crate::{EdgeAx, Hex, HexAx, NodeAx};

pub trait Hexes<THex>
where
  THex: Hex,
{
  fn hexes(&self) -> impl Iterator<Item = THex>;
}

impl Hexes<HexAx> for HexAx {
  fn hexes(&self) -> impl Iterator<Item = HexAx> {
    [
      HexAx::new(self.q, self.r + 1),
      HexAx::new(self.q + 1, self.r),
      HexAx::new(self.q + 1, self.r - 1),
      HexAx::new(self.q, self.r - 1),
      HexAx::new(self.q - 1, self.r),
      HexAx::new(self.q - 1, self.r + 1),
    ]
    .into_iter()
  }
}

impl Hexes<HexAx> for EdgeAx {
  fn hexes(&self) -> impl Iterator<Item = HexAx> {
    if self.q % 2 == 0 {
      [
        HexAx::new(self.q / 2, (self.r as f32 / 2.).ceil() as isize),
        HexAx::new(self.q / 2, (self.r as f32 / 2.).floor() as isize),
      ]
    } else {
      if self.r % 2 == 0 {
        [
          HexAx::new((self.q as f32 / 2.).ceil() as isize, self.r / 2),
          HexAx::new((self.q as f32 / 2.).floor() as isize, self.r / 2),
        ]
      } else {
        [
          HexAx::new(
            (self.q as f32 / 2.).floor() as isize,
            (self.r as f32 / 2.).ceil() as isize,
          ),
          HexAx::new(
            (self.q as f32 / 2.).ceil() as isize,
            (self.r as f32 / 2.).floor() as isize,
          ),
        ]
      }
    }
    .into_iter() // TODO
  }
}

impl Hexes<HexAx> for NodeAx {
  fn hexes(&self) -> impl Iterator<Item = HexAx> {
    match self.q.rem_euclid(3) {
      1 => {
        // Right side of edge (flat orientation)
        assert_eq!(self.r.rem_euclid(3), 1);
        [
          HexAx::new((self.q - 1) / 3, (self.r + 2) / 3),
          HexAx::new((self.q - 1) / 3, (self.r - 1) / 3),
          HexAx::new((self.q + 2) / 3, (self.r - 1) / 3),
        ]
      }
      2 => {
        // Left side of edge (flat orientation)
        assert_eq!(self.r.rem_euclid(3), 2);
        [
          HexAx::new((self.q - 2) / 3, (self.r + 1) / 3),
          HexAx::new((self.q + 1) / 3, (self.r + 1) / 3),
          HexAx::new((self.q + 1) / 3, (self.r - 2) / 3),
        ]
      }
      _ => panic!(
        "Tried to evaluate hexes of an invalid node coordinate: {:?}",
        self
      ),
    }
    .into_iter()
  }
}