Delete '

'

@@ -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
---]]
-