Hexer

hexer.gd

class_name Hexer

const SQRT_THREE := 1.7320508075688772
const SQRT_THREE_HALF := 0.8660254037844386

const axial_direction_vectors: Array[Vector2i] = [
    Vector2i(+1, 0), Vector2i(+1, -1), Vector2i(0, -1),
    Vector2i(-1, 0), Vector2i(-1, +1), Vector2i(0, +1),
]

static func loop(pos: Vector2i, range: int, callback: Callable) -> void:

    callback.call(pos)
    for radius in range - 1:
        radius += 1
        for dir_index in axial_direction_vectors.size():
            var dir: Vector2i = axial_direction_vectors[(dir_index + 2) % 6]
            var point: Vector2i = radius * axial_direction_vectors[dir_index]

            for i in radius:
                var tile_pos := pos + point + dir * i
                callback.call(tile_pos)

static func map_to_local(tile_pos: Vector2i, tile_size: Vector2) -> Vector2:

    return Vector2(
        (SQRT_THREE * tile_pos.x + SQRT_THREE_HALF * tile_pos.y) * tile_size.x,
        1.5 * tile_pos.y * tile_size.y
    )

static  func distance(a: Vector2i, b: Vector2i) -> int:
    var q := a.x - b.x
    var r := a.y - b.y
    var s := - q - r

    return (abs(q) + abs(r) + abs(s)) / 2

static func rotate(tile_pos: Vector2i, clock_wise: bool) -> Vector2i:
    var result := Vector2i()

    if clock_wise:
        result.x = - tile_pos.y
        result.y = tile_pos.x + tile_pos.y
    else:
        result.x = tile_pos.x + tile_pos.y
        result.y = -tile_pos.x

    return result

static func local_to_map(pos: Vector2, tile_size: Vector2) -> Vector2i:

    var float_q = (SQRT_THREE * pos.x  -  pos.y) / (3.0 * tile_size.x)
    var float_r = 2.0 * pos.y / (tile_size.y * 3.0)
    var float_s = -float_q - float_r

    var q = round(float_q)
    var r = round(float_r)
    var s = round(float_s)

    var q_frac = abs(float_q - q)
    var r_frac = abs(float_r - r)
    var s_frac = abs(float_s - s)

    if q_frac > r_frac and q_frac > s_frac:
        q = -r-s
    elif r_frac > s_frac:
        r = -q-s

    return Vector2i(q, r)