Vertexes and Edges handling

[f-hoenix]

Hello, thanks for this great crate 👍
I'm writting a small game using it and I find myself in need of interacting with the edges between the Hex
I did not find a lot of code related to it in the repo, did I miss something?
Somthing like this https://www.redblobgames.com/grids/parts/#hexagon-coordinates

I did find hex_corners() function https://docs.rs/hexx/0.13.0/src/hexx/layout.rs.html#101-104
But I can't easily specify a direction to filter only the wanted edge.

Is it something that's planned? I'm willing to contribute if it's not planned
Thanks again 👍

[ManevilleF]

That's feasible, basically you would want an API to retrieve a vertex position given a diagonal direction and an edge given a direction?

When you say edge, a [Vec2; 2] for example?

About the article you shared there is no plan yet for a real edge/vertex/face concept with relationships but I'm not opposed to it. What kind of use cases would that answer?

[f-hoenix]

This is the expected empty edge for the pointy layout

[f-hoenix]

Since the selected edge is off by 2, I would guess that the angle offset is computed in the wrong direction ?

[ManevilleF]

The offset is 30 degrees clockwise, I'm not sure what you mean by wrong direction

[f-hoenix]

This part feels weird:
On pointy layout, grid.layout.hex_corners[0] is the corner between (0,0);(1,0);(0;1) grid.layout.hex_corners[5] is the corner between (0,0);(0;1);(-1,1)
On flat layout, grid.layout.hex_corners[0] is the corner between (0,0);(1,0);(1;-1) grid.layout.hex_corners[5] is the corner between (0,0);(1;0);(0,1)
Since coordinates are not dependent on the layout, grid.layout.hex_corners[0] should yield the same corner independently of the layout

This is why the implem of get_edge_coordinates must do weird tricks in HexOrientation::Pointy layout

impl Edge {
    fn get_edge_coordinates(self: &Self, layout: &HexLayout) -> (Vec2, Vec2) {
        let (a, b) = {
            if layout.orientation == HexOrientation::Pointy {
                match self.direction {
                    Direction::TopRight => {(Direction::Top, Direction::TopLeft)}
                    Direction::Top => {(Direction::TopLeft, Direction::BottomLeft)}
                    Direction::TopLeft => {(Direction::BottomLeft, Direction::Bottom)}
                    Direction::BottomLeft => {(Direction::Bottom, Direction::BottomRight)}
                    Direction::Bottom => {(Direction::BottomRight, Direction::TopRight)}
                    Direction::BottomRight => {(Direction::TopRight, Direction::Top)}
                }
            } else {
                match self.direction {
                    Direction::TopRight => {(Direction::TopRight, Direction::Top)}
                    Direction::Top => {(Direction::Top, Direction::TopLeft)}
                    Direction::TopLeft => {(Direction::TopLeft, Direction::BottomLeft)}
                    Direction::BottomLeft => {(Direction::BottomLeft, Direction::Bottom)}
                    Direction::Bottom => {(Direction::Bottom, Direction::BottomRight)}
                    Direction::BottomRight => {(Direction::BottomRight, Direction::TopRight)}
                }
            }
        };
        let corners = layout.hex_corners(self.hex);
        (corners[a as usize], corners[b as usize])
    }
}

[ManevilleF]

The vertices are always in the same order and between the same coordinates, they follow Direction::ALL_DIRECTIONS. There might be an issue, it should probably use DiagonalDirection instead, as it represents vertex direction when Direction represents edge direction

I have some code cleaning that up and introducing grid types but it's not ready yet

[ManevilleF]

@f-hoenix Could you try the draft PR #154 and see if that could fit your use case ?

[f-hoenix]

I'll try this, it looks like it fits my use case yes