hexmap 0.2.1

A crate for creating and working with hex-based tile maps.
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

#[derive(PartialOrd, PartialEq, Debug, Copy, Clone)]
pub struct Orientation {
    pub f0: f32,
    pub f1: f32,
    pub f2: f32,
    pub f3: f32,
    pub b0: f32,
    pub b1: f32,
    pub b2: f32,
    pub b3: f32,
    pub start_angle: f32,
}

impl Orientation {
    const fn new(
        f0: f32,
        f1: f32,
        f2: f32,
        f3: f32,
        b0: f32,
        b1: f32,
        b2: f32,
        b3: f32,
        start_angle: f32,
    ) -> Orientation {
        Orientation {
            f0,
            f1,
            f2,
            f3,
            b0,
            b1,
            b2,
            b3,
            start_angle,
        }
    }
}

pub fn pointy() -> Orientation {
    Orientation::new(
        (3.0 as f32).sqrt(),
        (3.0 as f32).sqrt() / 2.0,
        0.0,
        3.0 / 2.0,
        (3.0 as f32).sqrt() / 3.0,
        -1.0 / 3.0,
        0.0,
        2.0 / 3.0,
        0.5,
    )
}

pub fn flat() -> Orientation {
    Orientation::new(
        3.0 / 2.0,
        0.0,
        (3.0 as f32).sqrt() / 2.0,
        (3.0 as f32).sqrt(),
        2.0 / 3.0,
        0.0,
        -1.0 / 3.0,
        (3.0 as f32).sqrt() / 3.0,
        0.0,
    )
}

#[derive(Debug, Copy, Clone)]
pub struct Layout {
    pub orientation: Orientation,
    pub size: Point,
    pub origin: Point,
}

impl Layout {
    pub const fn new(orientation: Orientation, size: Point, origin: Point) -> Layout {
        Layout {
            orientation,
            size,
            origin,
        }
    }
}

#[derive(PartialOrd, PartialEq, Debug, Copy, Clone)]
pub struct Point {
    pub x: f32,
    pub y: f32,
}

impl Point {
    pub const fn new(x: f32, y: f32) -> Point {
        Point { x, y }
    }

    pub const fn zero() -> Point {
        Point::new(0.0, 0.0)
    }
}