hex.py

import math
import json

# This uses oddr: shoves odd rows by +½ column
# Which is a pointy-top layout

axial_direction_vectors = [
    (+1, 0), (+1, -1), (0, -1), 
    (-1, 0), (-1, +1), (0, +1), 
]

F = math.sin(math.pi / 3)
if 0:
    height = 0.4
    size = F * height
else:
    # Horizontal spacing is 'size' apart
    # vertical spacing is 'height' apart
    size = 0.4
    height = size / F

def set_grid_size(s):
    global size, height
    size = s
    height = s / F
    print(f"{height=} {size=}")

def setsize(s):
    set_grid_size(s)

def cube_round(q, r, s):
    Iq = int(round(q))
    Ir = int(round(r))
    Is = int(round(s))

    q_diff = abs(Iq - q)
    r_diff = abs(Ir - r)
    s_diff = abs(Is - s)

    if q_diff > r_diff and q_diff > s_diff:
        Iq = -Ir-Is
    elif r_diff > s_diff:
        Ir = -Iq-Is
    else:
        Is = -Iq-Ir

    h = Hex(Iq, Ir)
    assert h.s == Is
    return h

class Hex:

    def __init__(self, q, r):
        assert isinstance(q, int) and isinstance(r, int)
        self.q = q
        self.r = r

    @property
    def s(self):
        return -self.q - self.r

    def to_grid(self):
        col = self.q + (self.r - (self.r&1)) / 2
        row = self.r
        return (col, row)

    def to_plane(self):
        (x, y) = self.to_grid()
        x += 0.5 * (y & 1)
        return (x * height, y * size)

    def hexagon(self):
        (x, y) = self.to_plane()
        xo = height / 2
        yo = size / 3
        return [
            (x - xo, y - yo),
            (x, y - 2*yo),
            (x + xo, y - yo),
            (x + xo, y + yo),
        ]

    def neighbors(self):
        yield(self)
        for (dq, dr) in axial_direction_vectors:
            yield(Hex(self.q + dq, self.r + dr))

    def neighborhood(self, R):
        for q in range(-R, R):
            for r in range(-R, R):
                for s in range(-R, R):
                    if (q + r + s) == 0:
                        yield self + Hex(q, r)

    def __add__(self, other):
        return Hex(self.q + other.q, self.r + other.r)

    def __sub__(self, other):
        return Hex(self.q - other.q, self.r - other.r)

    def __repr__(self):
        return f"<Hex q={self.q}, r={self.r} s={self.s}>"

    def distance(self, b):
        vec = self - b
        return (abs(vec.q) + abs(vec.r) + abs(vec.s)) // 2

    @classmethod
    def from_xy(cls, x, y):
        col = int(round((x) / height - 0.25))
        row = int(round(y / size))
        q = col - (row - (row & 1)) // 2
        r = row
        return cls(q, r)

    @classmethod
    def from_dc(cls, dc):
        return self.from_xy(dc.x, dc.y)

    @classmethod
    def from_xy_fine(cls, x, y):
        h = cls.from_xy(x, y)
        def dist(h):
            (x1, y1) = h.to_plane()
            return (x - x1) ** 2 + (y - y1) ** 2
        bydist = {dist(h): h for h in h.neighborhood(2)}
        return bydist[min(bydist)]

    def best_forward(self, p):
        brd = p.board
        candidates = []
        for nb in self.neighbors():
            xy = nb.to_plane()
            o = brd.DC(xy)
            # print(f"{hh=} {xy=}")
            (dx, dy) = p.seek(o)
            if dy >= 0:
                candidates.append((abs(dx), (dx, dy)))
        best = min(candidates)[1]
        return best

    def __iter__(self):
        yield self.q
        yield self.r

    def route(self, goal):
        return [self, goal]
        frontier = [self]
        came_from = {tuple(self): None}
        while tuple(goal) not in came_from:
            current = frontier.pop(0)
            for next in current.neighbors():
                if tuple(next) not in came_from:
                    frontier.append(next)
                    came_from[tuple(next)] = tuple(current)
        c = tuple(goal)
        path = [Hex(*c)]
        while c != tuple(self):
            c = came_from[c]
            path.append(Hex(*c))
        return path[::-1]

    def hop(self, other):
        d = self - other

        p1 = [self, Hex(other.q, self.r), other]
        p2 = [self, Hex(self.q, other.r), other]
        x = other.s - self.s
        p3 = [self, Hex(self.q - x, self.r), other]
        p4 = [self, Hex(self.q, self.r - x), other]
        def seg(a, b):
            q = abs(a.q - b.q)
            r = abs(a.r - b.r)
            s = abs(a.s - b.s)
            return max(q, r, s)
        def ll(hh):
            return sum([seg(a, b) for (a, b) in zip(hh, hh[1:])])
        ranked = {ll(p): p for p in (p1, p2, p3, p4)}
        return ranked[min(ranked)]

    def rot(self, a):
        a %= 6
        if a == 0:
            return self
        elif a == 1:
            return Hex(-self.r, -self.s)
        elif a == 2:
            return Hex(self.s, self.q)
        elif a == 3:
            return Hex(-self.q, -self.r)
        elif a == 4:
            return Hex(self.r, self.s)
        elif a == 5:
            return Hex(-self.s, -self.q)

    def __hash__(self):
        return hash((self.q, self.r))

    def __eq__(self, other):
        return (self.q, self.r) == (other.q, other.r)


    def line(self, b):

        def lerp(a, b, t):
            return a + (b - a) * t

        def cube_lerp(a, b, t):
            return (lerp(a.q, b.q, t),
                    lerp(a.r, b.r, t),
                    lerp(a.s, b.s, t))

        N = self.distance(b)
        results = []
        for i in range(N):
            results.append(cube_round(*cube_lerp(self, b, 1.0/N * i)))
        results.append(b)
        return results

def inrect(xy0, xy1):
    (x0, y0) = xy0
    (x1, y1) = xy1
    h0 = Hex.from_xy(x0, y0)
    h1 = Hex.from_xy(x1, y0)
    h2 = Hex.from_xy(x0, y1)
    qw = h1.q - h0.q

    h = h0
    for i in range(9999):
        if (i & 1) == 0:
            h.r += 1
        else:
            h.r += 1
            h.q -= 1
        if h.r == h2.r:
            break
        for q in range(h.q, h.q + qw):
            yield Hex(q, h.r)