churchianity
6 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 0 additions and 164 deletions
-
164'
@ -1,164 +0,0 @@ |
|||||
--[[ AXIAL/CUBE COORDINATE SYSTEM FOR AMULET/LUA]] |
|
||||
--[[ |
|
||||
|
|
||||
all hexes in functions are assumed to be amulet vectors. |
|
||||
in amulet, vector arithmetic works already with [ + - * / ] |
|
||||
things like equality and distance are implemented here. |
|
||||
|
|
||||
some algorithms use axial coordinates for hexes: vec2(s, t) |
|
||||
others use cube coordinates: vec3(s, t, z) where s + t + z = 0 |
|
||||
this is for simplicity - many algorithms don't care about the |
|
||||
third coordinate, and if they do, the missing coordinate can |
|
||||
be calculated from the other two. |
|
||||
|
|
||||
-- note on orientation: |
|
||||
because of the way amulet draws hexagons, it's much easier to assume |
|
||||
the user wants to use the flat map. rotation after the fact to |
|
||||
achieve other orienations is probably possible, but might have some |
|
||||
aliasing issues. TODO work on this. |
|
||||
|
|
||||
consequently, I have not implemented stretching. all hexagons are |
|
||||
assumed to be regular. you could implement this yourself by making |
|
||||
layout.size a vec2(sizex, sizey), but you would have to play with |
|
||||
transforms in the amulet library if you wanted to use amulet. |
|
||||
|
|
||||
some of the primary resources used to develop this library: |
|
||||
- https://redblobgames.com/grid/hexagons - simply amazing. |
|
||||
- http://amulet.xyz/doc - amulet documentation |
|
||||
- TODO that place that had the inner circle/outer circle ratio?? |
|
||||
|
|
||||
]] |
|
||||
|
|
||||
-- GENERALLY USEFUL CONSTANTS ------------------------------------------------- |
|
||||
|
|
||||
|
|
||||
|
|
||||
|
|
||||
|
|
||||
-- GENERALLY USEFUL FUNCTIONS -------------------------------------------------- |
|
||||
|
|
||||
function round(n) |
|
||||
return n % 1 >= 0.5 and math.ceil(n) or math.floor(n) |
|
||||
end |
|
||||
|
|
||||
function draw_axes(window, node) |
|
||||
xaxis = am.line(vec2(-window.width / 2, 0) , vec2(window.width / 2, 0)) |
|
||||
yaxis = am.line(vec2(0, -window.height / 2), vec2(0, window.height / 2)) |
|
||||
|
|
||||
node:append(xaxis) |
|
||||
node:append(yaxis) |
|
||||
end |
|
||||
|
|
||||
-- HEX CONSTANTS --------------------------------------------------------------- |
|
||||
|
|
||||
-- all possible vector directions from a given hex by edge |
|
||||
HEX_DIRECTIONS = {vec2( 1 , 0), |
|
||||
vec2( 1 , -1), |
|
||||
vec2( 0 , -1), |
|
||||
vec2(-1 , 0), |
|
||||
vec2(-1 , 1), |
|
||||
vec2( 0 , 1)} |
|
||||
|
|
||||
-- HEX UTILITY FUNCTIONS ------------------------------------------------------- |
|
||||
|
|
||||
function hex_equals(a, b) |
|
||||
return a.s == a.t and b.s == b.t |
|
||||
end |
|
||||
|
|
||||
function hex_nequals(a, b) |
|
||||
return not hex_equals(a, b) |
|
||||
end |
|
||||
|
|
||||
function hex_length(hex) |
|
||||
return ((math.abs(hex.s) + math.abs(hex.t) + math.abs(-hex.s - hex.t)) / 2) |
|
||||
end |
|
||||
|
|
||||
function hex_distance(a, b) |
|
||||
return hex_length(a - b) |
|
||||
end |
|
||||
|
|
||||
function hex_direction(direction) |
|
||||
return HEX_DIRECTIONS[direction] |
|
||||
end |
|
||||
|
|
||||
function hex_neighbour(hex, direction) |
|
||||
return hex + HEX_DIRECTIONS[direction] |
|
||||
end |
|
||||
|
|
||||
function hex_round(hex) |
|
||||
rs = round(hex.s) |
|
||||
rt = round(hex.t) |
|
||||
rz = round(-hex.s + -hex.t) |
|
||||
|
|
||||
sdelta = math.abs(rs - hex.s) |
|
||||
tdelta = math.abs(rt - hex.t) |
|
||||
zdelta = math.abs(rz + hex.s + hex.t) |
|
||||
|
|
||||
if sdelta > tdelta and sdelta > zdelta then |
|
||||
rs = -rt - rz |
|
||||
elseif tdelta > zdelta then |
|
||||
rt = -rs - rz |
|
||||
else |
|
||||
rz = -rs - rt |
|
||||
end |
|
||||
|
|
||||
return vec2(rs, rt) |
|
||||
end |
|
||||
|
|
||||
-- COORDINATE CONVERSION FUNCTIONS --------------------------------------------- |
|
||||
|
|
||||
-- forward & inverse matrices used for coordinate conversion |
|
||||
local M = mat2(3.0/2.0, 0.0, 3.0^0.5/2.0, 3.0^0.5 ) |
|
||||
local W = mat2(2.0/3.0, 0.0, -1.0/3.0 , 3.0^0.5/3.0) |
|
||||
|
|
||||
-- hex to screen |
|
||||
function hex_to_pixel(hex, origin) |
|
||||
|
|
||||
x = (M[1][1] * hex.s + M[1][2] * hex.t) * SIZE |
|
||||
y = (M[2][1] * hex.s + M[2][2] * hex.t) * SIZE |
|
||||
|
|
||||
return vec2(x + origin.x, y + origin.y) |
|
||||
end |
|
||||
|
|
||||
-- screen to hex |
|
||||
function pixel_to_hex(pix, origin) |
|
||||
pix = vec2(pix.x - origin.x) / SIZE, |
|
||||
(pix.y - origin.y) / SIZE |
|
||||
|
|
||||
s = W[1][1] * pix.x + W[1][2] * pix.y |
|
||||
t = W[2][1] * pix.x + W[2][2] * pix.y |
|
||||
|
|
||||
return hex_round(vec2(s, t)) |
|
||||
end |
|
||||
|
|
||||
-- MAP FUNCTIONS --------------------------------------------------------------- |
|
||||
|
|
||||
function hexagonal_map(radius, origin) |
|
||||
for s = -radius, radius do |
|
||||
t1 = math.max(-radius, -s - radius) |
|
||||
t2 = math.min(radius, -s + radius) |
|
||||
|
|
||||
for t = t1, t2 do |
|
||||
|
|
||||
color = vec4(math.random(20, 80) / 100, |
|
||||
math.random(20, 80) / 100, |
|
||||
math.random(20, 80) / 100, |
|
||||
1) |
|
||||
|
|
||||
map:append(am.circle(hex_to_pixel(vec2(s, t)), 24, color, 6)) |
|
||||
end |
|
||||
end |
|
||||
end |
|
||||
|
|
||||
function rectangular_map(width, height, origin) |
|
||||
for s = 0, height do |
|
||||
soffset = math.floor(s / 2) |
|
||||
|
|
||||
for t = -soffset, width - soffset do |
|
||||
|
|
||||
center = hex_to_pixel(vec2(s, t)) |
|
||||
end |
|
||||
end |
|
||||
end |
|
||||
--]] |
|
||||
|
|
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue