Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Fix conversions between axial and offset hex coords #416

Open
wants to merge 3 commits into
base: main
Choose a base branch
from
Open

Fix conversions between axial and offset hex coords #416

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
a086d93
Fix conversions between axial and offset hex coords
rparrett Apr 11, 2023
34738b1
Don't compile tests when not testing
rparrett Apr 11, 2023
ea1cfc7
Actually run tests in CI
rparrett Apr 11, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
40 changes: 20 additions & 20 deletions .github/workflows/ci.yml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -50,29 +50,29 @@ jobs:
command: doc
args: --all-features --no-deps

# test:
# name: Tests
# strategy:
# # Tests are most likely to have OS-specific behavior
# matrix:
# os: [ubuntu-latest, windows-latest, macOS-latest]
test:
name: Tests
strategy:
# Tests are most likely to have OS-specific behavior
matrix:
os: [ubuntu-latest, windows-latest, macOS-latest]

# runs-on: ${{ matrix.os }}
# steps:
# - name: Checkout sources
# uses: actions/checkout@v2
runs-on: ${{ matrix.os }}
steps:
- name: Checkout sources
uses: actions/checkout@v2

# - name: Install stable toolchain
# uses: actions-rs/toolchain@v1
# with:
# profile: minimal
# toolchain: stable
# override: true
- name: Install stable toolchain
uses: actions-rs/toolchain@v1
with:
profile: minimal
toolchain: stable
override: true

# - name: Run cargo test
# uses: actions-rs/cargo@v1
# with:
# command: test
- name: Run cargo test
uses: actions-rs/cargo@v1
with:
command: test

build_examples:
name: Build examples
Expand Down
197 changes: 180 additions & 17 deletions src/helpers/hex_grid/axial.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -108,72 +108,95 @@ impl From<AxialPos> for RowOddPos {
#[inline]
fn from(axial_pos: AxialPos) -> Self {
let AxialPos { q, r } = axial_pos;
let delta = r / 2;
RowOddPos { q: q + delta, r }

RowOddPos {
q: q + (r - (r & 1)) / 2,
r,
}
}
}

impl From<RowOddPos> for AxialPos {
#[inline]
fn from(offset_pos: RowOddPos) -> Self {
let RowOddPos { q, r } = offset_pos;
let delta = r / 2;
AxialPos { q: q - delta, r }

AxialPos {
q: q - (r - (r & 1)) / 2,
r,
}
}
}

impl From<AxialPos> for RowEvenPos {
#[inline]
fn from(axial_pos: AxialPos) -> Self {
let AxialPos { q, r } = axial_pos;
// (n + 1) / 2 is a ceil'ed rather than floored division
let delta = ceiled_division_by_2(r);
RowEvenPos { q: q + delta, r }

RowEvenPos {
q: q + (r + (r & 1)) / 2,
r,
}
}
}

impl From<RowEvenPos> for AxialPos {
#[inline]
fn from(offset_pos: RowEvenPos) -> Self {
let RowEvenPos { q, r } = offset_pos;
let delta = ceiled_division_by_2(r);
AxialPos { q: q - delta, r }

AxialPos {
q: q - (r + (r & 1)) / 2,
r,
}
}
}

impl From<AxialPos> for ColOddPos {
#[inline]
fn from(axial_pos: AxialPos) -> Self {
let AxialPos { q, r } = axial_pos;
let delta = q / 2;
ColOddPos { q, r: r + delta }

ColOddPos {
q,
r: r + (q - (q & 1)) / 2,
}
}
}

impl From<ColOddPos> for AxialPos {
#[inline]
fn from(offset_pos: ColOddPos) -> Self {
let ColOddPos { q, r } = offset_pos;
let delta = q / 2;
AxialPos { q, r: r - delta }

AxialPos {
q,
r: r - (q - (q & 1)) / 2,
}
}
}

impl From<AxialPos> for ColEvenPos {
#[inline]
fn from(axial_pos: AxialPos) -> Self {
let AxialPos { q, r } = axial_pos;
let delta = ceiled_division_by_2(q);
ColEvenPos { q, r: r + delta }

ColEvenPos {
q,
r: r + (q + (q & 1)) / 2,
}
}
}

impl From<ColEvenPos> for AxialPos {
#[inline]
fn from(offset_pos: ColEvenPos) -> Self {
let ColEvenPos { q, r } = offset_pos;
let delta = ceiled_division_by_2(q);
AxialPos { q, r: r - delta }

AxialPos {
q,
r: r - (q + (q & 1)) / 2,
}
}
}

Expand Down Expand Up @@ -497,3 +520,143 @@ impl From<AxialPos> for FractionalAxialPos {
}
}
}

#[cfg(test)]
mod tests {
use crate::prelude::{
axial::AxialPos,
offset::{ColEvenPos, ColOddPos, RowEvenPos, RowOddPos},
};

#[test]
fn row_odd_conversion() {
let coords = [
// zero
(RowOddPos { q: 0, r: 0 }, AxialPos { q: 0, r: 0 }),
// first ring
(RowOddPos { q: -1, r: -1 }, AxialPos { q: 0, r: -1 }),
(RowOddPos { q: 0, r: -1 }, AxialPos { q: 1, r: -1 }),
(RowOddPos { q: 1, r: 0 }, AxialPos { q: 1, r: 0 }),
(RowOddPos { q: 0, r: 1 }, AxialPos { q: 0, r: 1 }),
(RowOddPos { q: -1, r: 1 }, AxialPos { q: -1, r: 1 }),
(RowOddPos { q: -1, r: 0 }, AxialPos { q: -1, r: 0 }),
// second ring
(RowOddPos { q: -1, r: -2 }, AxialPos { q: 0, r: -2 }),
(RowOddPos { q: 0, r: -2 }, AxialPos { q: 1, r: -2 }),
(RowOddPos { q: 1, r: -2 }, AxialPos { q: 2, r: -2 }),
(RowOddPos { q: 1, r: -1 }, AxialPos { q: 2, r: -1 }),
(RowOddPos { q: 2, r: 0 }, AxialPos { q: 2, r: 0 }),
(RowOddPos { q: 1, r: 1 }, AxialPos { q: 1, r: 1 }),
(RowOddPos { q: 1, r: 2 }, AxialPos { q: 0, r: 2 }),
(RowOddPos { q: 0, r: 2 }, AxialPos { q: -1, r: 2 }),
(RowOddPos { q: -1, r: 2 }, AxialPos { q: -2, r: 2 }),
(RowOddPos { q: -2, r: 1 }, AxialPos { q: -2, r: 1 }),
(RowOddPos { q: -2, r: 0 }, AxialPos { q: -2, r: 0 }),
(RowOddPos { q: -2, r: -1 }, AxialPos { q: -1, r: -1 }),
];

for (row_odd, axial) in coords {
assert_eq!(row_odd, RowOddPos::from(axial));
assert_eq!(axial, AxialPos::from(row_odd));
}
}

#[test]
fn row_even_conversion() {
let coords = [
// zero
(RowEvenPos { q: 0, r: 0 }, AxialPos { q: 0, r: 0 }),
// first ring
(RowEvenPos { q: 0, r: -1 }, AxialPos { q: 0, r: -1 }),
(RowEvenPos { q: 1, r: -1 }, AxialPos { q: 1, r: -1 }),
(RowEvenPos { q: 1, r: 0 }, AxialPos { q: 1, r: 0 }),
(RowEvenPos { q: 1, r: 1 }, AxialPos { q: 0, r: 1 }),
(RowEvenPos { q: 0, r: 1 }, AxialPos { q: -1, r: 1 }),
(RowEvenPos { q: -1, r: 0 }, AxialPos { q: -1, r: 0 }),
// second ring
(RowEvenPos { q: -1, r: -2 }, AxialPos { q: 0, r: -2 }),
(RowEvenPos { q: 0, r: -2 }, AxialPos { q: 1, r: -2 }),
(RowEvenPos { q: 1, r: -2 }, AxialPos { q: 2, r: -2 }),
(RowEvenPos { q: 2, r: -1 }, AxialPos { q: 2, r: -1 }),
(RowEvenPos { q: 2, r: 0 }, AxialPos { q: 2, r: 0 }),
(RowEvenPos { q: 2, r: 1 }, AxialPos { q: 1, r: 1 }),
(RowEvenPos { q: 1, r: 2 }, AxialPos { q: 0, r: 2 }),
(RowEvenPos { q: 0, r: 2 }, AxialPos { q: -1, r: 2 }),
(RowEvenPos { q: -1, r: 2 }, AxialPos { q: -2, r: 2 }),
(RowEvenPos { q: -1, r: 1 }, AxialPos { q: -2, r: 1 }),
(RowEvenPos { q: -2, r: 0 }, AxialPos { q: -2, r: 0 }),
(RowEvenPos { q: -1, r: -1 }, AxialPos { q: -1, r: -1 }),
];

for (row_even, axial) in coords {
assert_eq!(row_even, RowEvenPos::from(axial));
assert_eq!(axial, AxialPos::from(row_even));
}
}

#[test]
fn col_odd_conversion() {
let coords = [
// zero
(ColOddPos { q: 0, r: 0 }, AxialPos { q: 0, r: 0 }),
// first ring
(ColOddPos { q: 0, r: -1 }, AxialPos { q: 0, r: -1 }),
(ColOddPos { q: 1, r: -1 }, AxialPos { q: 1, r: -1 }),
(ColOddPos { q: 1, r: 0 }, AxialPos { q: 1, r: 0 }),
(ColOddPos { q: 0, r: 1 }, AxialPos { q: 0, r: 1 }),
(ColOddPos { q: -1, r: 0 }, AxialPos { q: -1, r: 1 }),
(ColOddPos { q: -1, r: -1 }, AxialPos { q: -1, r: 0 }),
// second ring
(ColOddPos { q: 0, r: -2 }, AxialPos { q: 0, r: -2 }),
(ColOddPos { q: 1, r: -2 }, AxialPos { q: 1, r: -2 }),
(ColOddPos { q: 2, r: -1 }, AxialPos { q: 2, r: -2 }),
(ColOddPos { q: 2, r: 0 }, AxialPos { q: 2, r: -1 }),
(ColOddPos { q: 2, r: 1 }, AxialPos { q: 2, r: 0 }),
(ColOddPos { q: 1, r: 1 }, AxialPos { q: 1, r: 1 }),
(ColOddPos { q: 0, r: 2 }, AxialPos { q: 0, r: 2 }),
(ColOddPos { q: -1, r: 1 }, AxialPos { q: -1, r: 2 }),
(ColOddPos { q: -2, r: 1 }, AxialPos { q: -2, r: 2 }),
(ColOddPos { q: -2, r: 0 }, AxialPos { q: -2, r: 1 }),
(ColOddPos { q: -2, r: -1 }, AxialPos { q: -2, r: 0 }),
(ColOddPos { q: -1, r: -2 }, AxialPos { q: -1, r: -1 }),
];

for (col_odd, axial) in coords {
assert_eq!(col_odd, ColOddPos::from(axial));
assert_eq!(axial, AxialPos::from(col_odd));
}
}

#[test]
fn col_even_conversion() {
let coords = [
// zero
(ColEvenPos { q: 0, r: 0 }, AxialPos { q: 0, r: 0 }),
// first ring
(ColEvenPos { q: 0, r: -1 }, AxialPos { q: 0, r: -1 }),
(ColEvenPos { q: 1, r: 0 }, AxialPos { q: 1, r: -1 }),
(ColEvenPos { q: 1, r: 1 }, AxialPos { q: 1, r: 0 }),
(ColEvenPos { q: 0, r: 1 }, AxialPos { q: 0, r: 1 }),
(ColEvenPos { q: -1, r: 1 }, AxialPos { q: -1, r: 1 }),
(ColEvenPos { q: -1, r: 0 }, AxialPos { q: -1, r: 0 }),
// second ring
(ColEvenPos { q: 0, r: -2 }, AxialPos { q: 0, r: -2 }),
(ColEvenPos { q: 1, r: -1 }, AxialPos { q: 1, r: -2 }),
(ColEvenPos { q: 2, r: -1 }, AxialPos { q: 2, r: -2 }),
(ColEvenPos { q: 2, r: 0 }, AxialPos { q: 2, r: -1 }),
(ColEvenPos { q: 2, r: 1 }, AxialPos { q: 2, r: 0 }),
(ColEvenPos { q: 1, r: 2 }, AxialPos { q: 1, r: 1 }),
(ColEvenPos { q: 0, r: 2 }, AxialPos { q: 0, r: 2 }),
(ColEvenPos { q: -1, r: 2 }, AxialPos { q: -1, r: 2 }),
(ColEvenPos { q: -2, r: 1 }, AxialPos { q: -2, r: 2 }),
(ColEvenPos { q: -2, r: 0 }, AxialPos { q: -2, r: 1 }),
(ColEvenPos { q: -2, r: -1 }, AxialPos { q: -2, r: 0 }),
(ColEvenPos { q: -1, r: -1 }, AxialPos { q: -1, r: -1 }),
];

for (col_even, axial) in coords {
assert_eq!(col_even, ColEvenPos::from(axial));
assert_eq!(axial, AxialPos::from(col_even));
}
}
}