Struct HexagonalBoard

pub struct HexagonalBoard<T> { /* private fields */ }

A board composed of hexagons.

You can construct a HexagonalBoard the same ways you would construct a HashMap, where the keys are something that can be converted to a glam::IVec2 (e.g., [i32; 2]).

The positions are interpreted as hexagonal coordinates, where the basis [1, 0] is the hexagon to the left and up, and [0, 1] is the one to the right and up.

You can render a HexagonalBoard using HexagonalBoard::render if T: Into<char> + Clone. Otherwise, you can use HexagonalBoard::render_with to specify how to convert the T into a char.

You can also use HexagonalBoard::char_map if you want to easily get what character should be printed where, but you want to do the rendering yourself.

Examples

Basic usage:

use hext_boards::HexagonalBoard;

// Put an `'A'` at `[0, 0]` and a `'B'` at `[1, 1]`.
let board = HexagonalBoard::from([
    ([0, 0], 'A'),
    ([1, 1], 'B'),
]);

let output = board.render();
let expected = indoc::indoc!(
    r"
         /---\
        ⟨  B  ⟩
         ⟩---⟨
        ⟨  A  ⟩
         \---/
    "
).trim_end_matches('\n');

println!("{output}");

assert_eq!(output, expected)

Using HexagonalBoard::render_with:

use hext_boards::HexagonalBoard;

let board = HexagonalBoard::from([
    ([0, 0], 5),
    ([0, 1], 13),
    ([1, 1], 25),
]);

// Everything needs to be one char, so we have to use hexadecimal or some other radix to
// output higher numbers.
let output = board.render_with(|n| char::from_digit(*n, 36).expect("`n` is less than 36."));

let expected = indoc::indoc!(
    r"
         /---\
        ⟨  p  ⟩---\
         ⟩---⟨  d  ⟩
        ⟨  5  ⟩---/
         \---/
    "
).trim_end_matches('\n');

assert_eq!(output, expected)

Implementations

impl<T> HexagonalBoard<T>

pub fn char_map(&self, into_char: impl Fn(&T) -> char) -> HashMap<IVec2, char>

Map from coordinates

pub fn render_with(&self, into_char: impl Fn(&T) -> char) -> String

Renders the hexagonal board into a String, converting the Ts into chars using into_char.

If T can easily be converted to a char (i.e., T: Into<char> + Copy), you can use Self::render.

pub fn render(&self) -> String

where for<'a> char: From<T>, T: Copy,

Renders the hexagonal board into a String.

To specify how to convert the T into a char, see Self::render_with.

Trait Implementations

impl<T: Clone> Clone for HexagonalBoard<T>

fn clone(&self) -> HexagonalBoard<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for HexagonalBoard<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default> Default for HexagonalBoard<T>

fn default() -> HexagonalBoard<T>

Returns the “default value” for a type.

impl<T> Display for HexagonalBoard<T>

where for<'a> char: From<T>, T: Copy,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<P: Into<IVec2>, T, V> From<V> for HexagonalBoard<T>

where V: IntoIterator<Item = (P, T)>,

fn from(value: V) -> Self

Converts to this type from the input type.

impl<P: Into<IVec2>, T> FromIterator<(P, T)> for HexagonalBoard<T>

fn from_iter<I: IntoIterator<Item = (P, T)>>(iter: I) -> Self

Creates a value from an iterator.