diff --git a/' b/' new file mode 100644 index 0000000..720698e --- /dev/null +++ b/' @@ -0,0 +1,164 @@ +--[[ 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 +--]] + diff --git a/; b/; new file mode 100644 index 0000000..c3ae1e4 --- /dev/null +++ b/; @@ -0,0 +1,67 @@ +----- [[ WARZONE 2 - HEXAGONAL GRID RESOURCE BASED TOWER DEFENSE GAME]] -------- +--[[ author@churchianity.ca + ]] + +require "hex" +require "util" + +local win = am.window{ + -- BASE RESOLUTION = 3/4 * WXGA Standard 16:10 + width = 1280 * 3 / 4, -- 960px + height = 800 * 3 / 4, -- 600px + + title = "Warzone 2: Electric Boogaloo"} + +local title = am.group() +local world = am.group() +local layout = hex_layout(vec2(-368, win.bottom)) +local map = hex_rectangular_map(45, 31) + + + +function show_axes() + xaxis = am.line(vec2(win.left, 0), vec2(win.right, 0)) + yaxis = am.line(vec2(0, win.top), vec2(0, win.bottom)) + world:append(am.group{xaxis, yaxis}:tag("axes")) +end + +function world_init() + world:action(coroutine.create(function() + for hex,_ in pairs(map) do + world:append(am.circle(hex_to_pixel(hex, layout), 11, rrgb(1), 6)) + am.wait(am.delay(0.01)) + end + end)) + +end + +function init() + titlemap = am.group() + + for hex,_ in pairs(map) do + titlemap:append(am.rotate(45):tag("titlemap") + ^ am.scale(3, 2) + ^ am.circle(hex_to_pixel(hex, layout), 11, rrgb(1), 6)) + end + + local line1 = am.text("WARZONE 2") + local line2 = am.text("Electric Boogaloo") + local line3 = am.text("by Nick Hayashi") + local title = am.group{titlemap, + am.translate(0, 150) ^ am.scale(4) ^ line1, + am.translate(0, 100) ^ am.scale(3) ^ line2, + am.translate(0, 60) ^ am.scale(1) ^ line3 + }:action(function() + while true do + titlemap"titlemap".angle = am.frame_time * 4 + end + end) + + + win.scene = title +end + +----- [[ MAIN ]] --------------------------------------------------------------- + +init() + diff --git a/README.md b/README.md new file mode 100644 index 0000000..891cae9 --- /dev/null +++ b/README.md @@ -0,0 +1,61 @@ +----- INTRODUCTION [1.1] --------------------------------------------------- +--[[ author@churchianity.ca + + this is a library for using hexagonal grids in amulet/lua. + it is extremely incomplete. the following list of features is + either implemented shoddily, or not at all. + + if you want an actual good resource, go to [1.9]. + +----- COORDINATE SYSTEMS [1.2] ---------------------------------------------- + + * as much coordinate manipulation as possible is done internally. + depending on the task, uses either Axial, Cube, or Doubled coordinates. + + * three different ways of returning and sending coordinates: + + 1) amulet vectors + 2) lua tables + 3) individual coordinate numbers + + so you can use what your graphics library likes best! + +----- MAPS & MAP STORAGE [1.3] ------------------------------------------------- + + some map shapes: parallelogram, rectangular, hexagonal, triangular. (and more) + * storage system based on map shape - see chart: + + ________________________________________________________________________ + | SHAPE : MAP STORAGE | + |------------------------------------------------------------------------| + | parallelogram : unordered, hash-like OR ordered, array-like | + | rectangular : unordered, hash-like OR ordered, array-like | + | hexagonal : unordered, hash-like OR ordered, array-like | + | triangular : unordered, hash-like OR ordered, array-like | + | ring : ordered, array-like | + | spiral : ordered, array-like** | + | arbitrary : unordered, hash-like | + |________________________________________________________________________| + ** note that a spiral map is just a hexagonal one with a particular order. + + +----- CONVENTIONS AND TERMINOLOGY [1.8] ----------------------------------------- + + because so many different kinds of coordinate pairs, trios + + +----- RESOURCES USED TO DEVELOP THIS LIBRARY, AND FOR WHICH I AM GRATEFUL [1.9] - + + * https://catlikecoding.com/unity/tutorials/hex-map/ + -> unity tutorial for hexagon grids with some useful generalized math. + + * https://youtube.com/watch?v=fNk_zzaMoSs&list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab + -> amazing series on linear algebra by 3Blue1Brown + + * https://redblobgames.com/grid/hexagons + -> now THE resource on hexagonal grids on the internet. + + * http://amulet.xyz/doc + -> amulet documentation. + ]] + diff --git a/hex.lua b/hex.lua index 3dee70d..fead051 100644 --- a/hex.lua +++ b/hex.lua @@ -1,16 +1,3 @@ ------ [[ AXIAL/CUBE COORDINATE HEXAGON LIBRARY FOR AMULET/LUA]] ---------------- ---[[ author@churchianity.ca - -- INTRODUCTION - this is a hexagonal grid library for amulet/lua. - it uses axial coordinates or cube/hex coordinates when necessary. - by amulet convention, hexes are either vec2(s, t) or vec3(s, t, z) - but nearly always the former. - - -- RESOURCES USED TO DEVELOP THIS LIBRARY, AND FOR WHICH I AM GRATEFUL - https://catlikecoding.com/unity/tutorials/hex-map/ - https://redblobgames.com/grid/hexagons - http://amulet.xyz/doc - ]] ----- [[ GENERALLY USEFUL FUNCTIONS ]] ----------------------------------------- @@ -22,51 +9,53 @@ end ----- [[ HEX CONSTANTS & UTILITY FUNCTIONS ]] ---------------------------------- -- all possible vector directions from a given hex by edge -local HEX_DIRECTIONS = {vec2( 1 , 0), - vec2( 1 , -1), - vec2( 0 , -1), - vec2(-1 , 0), - vec2(-1 , 1), - vec2( 0 , 1)} +local CUBE_DIRECTIONS = {vec2( 1 , 0), + vec2( 1 , -1), + vec2( 0 , -1), + vec2(-1 , 0), + vec2(-1 , 1), + vec2( 0 , 1)} -- return hex vector direction via integer index |direction|. -function hex_direction(direction) - return HEX_DIRECTIONS[(6 + (direction % 6)) % 6 + 1] +function cube_direction(direction) + return CUBE_DIRECTIONS[(6 + (direction % 6)) % 6 + 1] end -- return hexagon adjacent to |hex| in integer index |direction|. -function hex_neighbour(hex, direction) +function cube_neighbour(hex, direction) return hex + HEX_DIRECTIONS[(6 + (direction % 6)) % 6 + 1] end --- TODO -function hex_rotate_left(hex) +-- TODO rotations are different depending on the coordinate system you use. +-- implement this for cube/axial, and doubled. +function cube_rotate_left(hex) end -function hex_rotate_right(hex) +function cube_rotate_right(hex) end --- rounds hexes. without this, pixel_to_hex returns fractional coordinates. -function hex_round(s, t) - local rs = round(s) - local rt = round(t) - local rz = round(-s - t) +-- rounds a float coordinate trio |x, y, z| to its nearest integer coordinate trio. +-- TODO make work with a table {x, y, z} and vec3(x, y, z) +function cube_round(x, y, z) + local rx = round(x) + local ry = round(y) + local rz = round(z) - local sdelta = math.abs(rs - s) - local tdelta = math.abs(rt - t) - local zdelta = math.abs(rz - (-s - t)) + local xdelta = math.abs(rx - x) + local ydelta = math.abs(ry - y) + local zdelta = math.abs(rz - z) - if sdelta > tdelta and sdelta > zdelta then - rs = -rt - rz - elseif tdelta > zdelta then - rt = -rs - rz + if xdelta > ydelta and xdelta > zdelta then + rx = -ry - rz + elseif ydelta > zdelta then + rx = -ry - rz else - rz = -rs - rt + rz = -rx - ry end - return vec2(rs, rt) + return vec3(rx, ry, rz) end ----- [[ LAYOUT, ORIENTATION & COORDINATE CONVERSION ]] ----------------------- @@ -81,26 +70,25 @@ local POINTY = {M = mat2(3.0^0.5, 3.0^0.5/2.0, 0.0, 3.0/2.0), W = mat2(3.0^0.5/3.0, -1.0/3.0, 0.0, 2.0/3.0), start_angle = 0.5} --- TODO encapsulate hex_to_pixel and pixel_to_hex in layout table. --- stores layout information that does not pertain to map shape -function hex_layout(origin, size, orientation) +-- stores layout: information that does not pertain to map shape +function layout(origin, size, orientation) return {origin = origin or vec2(0), - size = size or vec2(12), + size = size or vec2(11), orientation = orientation or FLAT} end -- hex to screen -function hex_to_pixel(hex, layout) +function cube_to_pixel(cube, layout) local M = layout.orientation.M - local x = (M[1][1] * hex.s + M[1][2] * hex.t) * layout.size.x - local y = (M[2][1] * hex.s + M[2][2] * hex.t) * layout.size.y + local x = (M[1][1] * cube.x + M[1][2] * cube.y) * layout.size.x + local y = (M[2][1] * cube.x + M[2][2] * cube.y) * layout.size.y return vec2(x + layout.origin.x, y + layout.origin.y) end -- screen to hex -function pixel_to_hex(pix, layout) +function pixel_to_cube(pix, layout) local W = layout.orientation.W local pix = (pix - layout.origin) / layout.size @@ -108,28 +96,47 @@ function pixel_to_hex(pix, layout) local s = W[1][1] * pix.x + W[1][2] * pix.y local t = W[2][1] * pix.x + W[2][2] * pix.y - return hex_round(s, t) + return cube_round(s, t, -s - t) end --- TODO test -function hex_corner_offset(layout, corner) +function hex_corner_offset(corner, layout) local angle = 2.0 * math.pi * layout.orientation.start_angle + corner / 6 return vec2(layout.size.x * math.cos(angle), layout.size.y * math.sin(angle)) end --- TODO make do stuff -function hex_corners(layout, hex) +function hex_corners(hex, layout) local corners = {} end +function cube_to_offset(cube) + +end + +function offset_to_cube(off) + +end + +function cube_to_doubled(cube) + return vec2(cube.x, 2 * (-cube.x - cube.y) + cube.x) +end + +function doubled_to_cube(dbl) + return vec2(dbl.x, (dbl.y - dbl.x) / 2) +end + ----- [[ MAP STORAGE & RETRIEVAL ]] -------------------------------------------- --[[ + TODO make all functions work regardless of layout. as it stands, they kind + of do, just not always nicely. ]] --- TODO make all functions work regardless of layout. -- returns ordered ring-shaped map of |radius| from |center|. -function hex_ring_map(center, radius) +function ring_map(center, radius) local map = {} + local mt = {__index={center=center, radius=radius}} + + setmetatable(map, mt) + local walk = center + HEX_DIRECTIONS[6] * radius for i = 1, 6 do @@ -141,9 +148,15 @@ function hex_ring_map(center, radius) return map end --- returns ordered hexagonal map of |radius| rings from |center|. -function hex_spiral_map(center, radius) +--[[ returns ordered hexagonal map of |radius| rings from |center|. + the only difference between hex_spiral_map and hex_hexagonal_map is that + hex_spiral_map is ordered, in a spiral path from the |center|. + ]] +function spiral_map(center, radius) local map = {center} + local mt = {__index={center=center, radius=radius}} + + setmetatable(map, mt) for i = 1, radius do table.append(map, hex_ring_map(center, i)) @@ -152,7 +165,7 @@ function hex_spiral_map(center, radius) end -- returns unordered parallelogram-shaped map of |width| and |height|. -function hex_parallelogram_map(width, height) +function parallelogram_map(width, height) local map = {} local mt = {__index={width=width, height=height}} @@ -167,7 +180,7 @@ function hex_parallelogram_map(width, height) end -- returns unordered triangular map of |size|. -function hex_triangular_map(size) +function triangular_map(size) local map = {} local mt = {__index={size=size}} @@ -182,7 +195,7 @@ function hex_triangular_map(size) end -- returns unordered hexagonal map of |radius|. -function hex_hexagonal_map(radius) +function hexagonal_map(radius) local map = {} local mt = {__index={radius=radius}} @@ -200,7 +213,7 @@ function hex_hexagonal_map(radius) end -- returns unordered rectangular map of |width| and |height|. -function hex_rectangular_map(width, height) +function rectangular_map(width, height) local map = {} local mt = {__index={width=width, height=height}} @@ -214,3 +227,6 @@ function hex_rectangular_map(width, height) return map end +----- [[ TESTS ]] -------------------------------------------------------------- + + diff --git a/main.lua b/main.lua index 211bb4e..622741b 100644 --- a/main.lua +++ b/main.lua @@ -2,8 +2,8 @@ --[[ author@churchianity.ca ]] -require "hex" -require "util" +require"hex" +require"util" ------ [[ GLOBALS ]] ----------------------------------------------------------- @@ -12,99 +12,86 @@ local win = am.window{ width = 1280 * 3 / 4, -- 960px height = 800 * 3 / 4, -- 600px title = "Warzone 2: Electric Boogaloo", - clear_color = vec4(22/255, 22/255, 29/255, 1) + resizable = false } -local title -local world -local layout = hex_layout() -local map = hex_hexagonal_map(24) +local layout = layout(vec2(-268, win.bottom)) +local map = rectangular_map(45, 31) +local world = am.group{}:tag"world" ----- [[ SPRITES ]] ------------------------------------------------------------ -local titlebutton = [[ + +-- modified ethan shoonover solarized colortheme +am.ascii_color_map = { + E = vec4( 22/255, 22/255, 29/255, 1), -- eigengrau + + K = vec4( 0, 43/255, 54/255, 1), -- dark navy + k = vec4( 7/255, 54/255, 66/255, 1), -- navy + L = vec4( 88/255, 110/255, 117/255, 1), -- gray1 + l = vec4(101/255, 123/255, 131/255, 1), -- gray2 + + s = vec4(131/255, 148/255, 150/255, 1), -- gray3 + S = vec4(147/255, 161/255, 161/255, 1), -- gray4 + w = vec4(238/255, 232/255, 213/255, 1), -- bone + W = vec4(253/255, 246/255, 227/255, 1), -- white + + y = vec4(181/255, 137/255, 0, 1), -- yellow + o = vec4(203/255, 75/255, 22/255, 1), -- orange + r = vec4(220/255, 50/255, 47/255, 1), -- red + m = vec4(211/255, 54/255, 130/255, 1), -- magenta + v = vec4(108/255, 113/255, 196/255, 1), -- violet + b = vec4( 38/255, 139/255, 210/255, 1), -- blue + c = vec4( 42/255, 161/255, 152/255, 1), -- cyan + g = vec4(133/255, 153/255, 0, 1) -- green +} +local titlebutton = +[[ KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK KwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwK -KwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbK -KwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbK -KwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbK -KwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbK -KwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbK -KwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbK -KwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbK -KwbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbK -KbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbK +KwkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkK +KwkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkK +KwkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkK +KwkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkK +KwkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkK +KwkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkK +KwkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkK +KwkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkK +KkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkK KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK - ]] +]] +----- [[ FUNCTIONS ]] ---------------------------------------------------------- -function world_init() - world = am.group{} - world:action(coroutine.create(function() - for hex,_ in pairs(map) do - world:append(am.circle(hex_to_pixel(hex, layout), 12, rrgb(1), 6)) - am.wait(am.delay(0.01)) - end - end)) - win.scene = world +function show_axes() + local xaxis = am.line(vec2(win.left, 0), vec2(win.right, 0)) + local yaxis = am.line(vec2(0, win.top), vec2(0, win.bottom)) + win.scene:append(am.translate(0, 0) ^ am.group{xaxis, yaxis}:tag"axes") end -function init() - - local titlemenu = am.group{ - am.translate(0, 150) - ^ {am.scale(6.5) - ^ am.text("WARZONE 2", vec4(0, 0, 0, 1)), - am.scale(6.3, 6.7) - ^ am.text("WARZONE 2")}, - - am.translate(0, 80) - ^ am.text("a tower defense game"), - - am.translate(0, 0) - ^ {am.scale(3) - ^ am.sprite(titlebutton), - am.text("NEW GAME")}, - - am.translate(0, -40) - ^ {am.scale(3) - ^ am.sprite(titlebutton), - am.text("LOAD GAME")}, - - am.translate(0, -80) - ^ {am.scale(3) - ^ am.sprite(titlebutton), - am.text("SETTINGS")}, - - am.translate(0, -120) - ^ {am.scale(3) - ^ am.sprite(titlebutton), - am.text("QUIT")}, - - am.translate(0, -250) - ^ am.text("by nick hayashi") - } - - local backdrop = am.group() +function show_hex_coords() + win.scene:action(function() + win.scene:remove("coords") + + local mouse = axial_to_doubled(pixel_to_hex(win:mouse_position(), layout)) + + if mouse.x > 0 and mouse.x < 45 and mouse.y < 0 and mouse.y > -63 then + local coords = am.group{ + am.translate(win.left + 30, win.top - 10) + ^ am.text(string.format("%d,%d", mouse.x, mouse.y)):tag"coords"} + win.scene:append(coords) + end + end) +end +function init() for hex,_ in pairs(map) do - local center = hex_to_pixel(hex, layout) - backdrop:append(am.circle(center, 12, rhue(1), 6)) + local pix = hex_to_pixel(hex, layout) + world:append(am.circle(pix, 11, rhue(1), 6)) end - - title = am.group{ - am.translate(win.right, win.bottom) - ^ am.scale(3.5, 1.5) - ^ am.rotate(0) - ^ backdrop, - - titlemenu - }:action(function() - title"rotate".angle = am.frame_time / 36 - end) - - win.scene = title + + win.scene = world end ----- [[ MAIN ]] --------------------------------------------------------------- init() - +show_hex_coords() diff --git a/util.lua b/util.lua index aa08a0c..14dc1cf 100644 --- a/util.lua +++ b/util.lua @@ -11,11 +11,3 @@ end function rmono() return vec4(1, 1, 1, math.random()) end - - -function show_axes() - xaxis = am.line(vec2(win.left, 0), vec2(win.right, 0)) - yaxis = am.line(vec2(0, win.top), vec2(0, win.bottom)) - world:append(am.group{xaxis, yaxis}:tag("axes")) -end -