Browse Source

wowza

master
churchianity 6 years ago
parent
commit
f4df2ec8fa
  1. 77
      hex.lua
  2. 30
      main.lua

77
hex.lua

@ -58,7 +58,7 @@ function hex_round(s, t)
sdelta = math.abs(rs - s)
tdelta = math.abs(rt - t)
zdelta = math.abs(rz + s + t)
zdelta = math.abs(rz - (-s - t))
if sdelta > tdelta and sdelta > zdelta then
rs = -rt - rz
@ -82,13 +82,10 @@ POINTY_ORIENTATION = {3.0^0.5, 3.0^0.5/2.0, 0.0, 3.0/2.0,
3.0^0.5/3.0, -1.0/3.0, 0.0, 2.0/3.0}
-- layout.
function layout(size, orientation, origin, width, height, radius)
return {size = size or {11, 11},
orientation = orientation or FLAT_ORIENTATION,
origin = origin or {0, 0},
width = width or 45,
height = height or 31,
radius = radius or width or 6}
function layout_init(origin, size, orientation)
return {origin = origin or {0, 0},
size = size or {11, 11},
orientation = orientation or FLAT_ORIENTATION}
end
-- hex to screen
@ -115,29 +112,33 @@ function pixel_to_hex(x, y, layout)
end
----- [[ MAP STORAGE & RETRIEVAL ]] --------------------------------------------
--[[ all functions return a table of tables; a map of points
storage functions take a range of hex coordinates, and return pixel ones.
retrieval functions do the opposite.
everything except map shape is determined by layout.
pick a pair of functions based on the shape of map you want to use.
it is not advised to use a single layout instance with multiple shapes. ]]
-- returns parallelogram-shaped map. width and height are used.
function ogram_map_store(layout)
--[[ _init functions return a table of tables;
a map of points in a chosen shape and specified layout.
the shape, as well as the layout used is stored in a metatable
for reuse.
]]
-- returns parallelogram-shaped map.
function map_parallelogram_init(layout, width, height)
map = {}
for s = 0, layout.width do
for t = 0, layout.height do
setmetatable(map, {__index={layout=layout, shape=parallelogram}})
for s = 0, width do
for t = 0, height do
table.insert(map, hex_to_pixel(s, t, layout))
end
end
return map
end
-- returns triangular map. radius is used as the triangle side length.
function tri_map_store(layout)
-- returns triangular map.
function map_triangular_init(layout, size)
map = {}
for s = 0, layout.radius do
for t = layout.radius - s, layout.radius do
setmetatable(map, {__index={layout=layout, shape=triangular}})
for s = 0, size do
for t = size - s, size do
table.insert(map, hex_to_pixel(s, t, layout))
end
end
@ -145,11 +146,13 @@ function tri_map_store(layout)
end
-- returns hexagonal map. length of map is radius * 2 + 1
function hex_map_store(layout)
function map_hexagonal_init(layout, radius)
map = {}
for s = -layout.radius, layout.radius do
t1 = math.max(-layout.radius, -s - layout.radius)
t2 = math.min(layout.radius, -s + layout.radius)
setmetatable(map, {__index={layout=layout, shape=hexagonal}})
for s = -radius, radius do
t1 = math.max(-radius, -s - radius)
t2 = math.min(radius, -s + radius)
for t = t1, t2 do
table.insert(map, hex_to_pixel(s, t, layout))
@ -158,16 +161,28 @@ function hex_map_store(layout)
return map
end
-- returns rectangular map. width and height are used.
function rect_map_store(layout)
-- returns rectangular map.
function map_rectangular_init(layout, width, height)
map = {}
for s = 0, layout.width do
setmetatable(map, {__index={layout=layout, shape=rectangular}})
for s = 0, width do
soffset = math.floor(s/2)
for t = -soffset, layout.height - soffset do
for t = -soffset, height - soffset do
table.insert(map, hex_to_pixel(s, t, layout))
end
end
return map
end
-- places single hex into map table, if it is not already present.
function map_store(map)
end
-- retrieves single hex from map table, if it is present.
function map_retrieve(map)
end

30
main.lua

@ -19,14 +19,7 @@ function rcolor()
return vec4(math.random(20, 80) / 100)
end
function show_hex_coords()
win.scene:action(function()
x, y = unpack(pixel_to_hex(win:mouse_position().x, win:mouse_position().y, layout))
test_scene = (
am.translate(vec2(unpack(hex_to_pixel(x, y, layout))))
^ am.text(string.format("%d, %d", x, y)))
end)
end
----- [[ BLAH BLAH LBAH ]] -----------------------------------------------
local win = am.window {
title = "Warzone 2: Electric Boogaloo",
@ -35,21 +28,18 @@ local win = am.window {
width = 1280 * 3 / 4, -- 960
height = 800 * 3 / 4} -- 600
local layout = layout({11, 11},
FLAT_ORIENTATION,
vec2(win.left, win.bottom),
45, 31)
local layout = layout_init({win.left, win.bottom})
----- [[ MAP RENDERING ]] ------------------------------------------------
function render_map(layout)
coords = rect_map_store(layout)
map = am.group()
map = map_rectangular_init(layout, 45, 31)
hexagons = am.group()
for _,v in pairs(coords) do
map:append(am.circle(vec2(unpack(v)), layout.size[1], rcolor(), 6))
for _,v in pairs(map) do
hexagons:append(am.circle(vec2(unpack(v)), layout.size[1], rcolor(), 6))
end
return map
return hexagons
end
----- [[ MAIN ]] -----------------------------------------------------------
@ -61,8 +51,6 @@ win.scene = am.group{test_scene, game_scene}
test_scene:action(function()
x, y = unpack(pixel_to_hex(win:mouse_position().x, win:mouse_position().y, layout))
test_scene:replace("text",
am.translate(vec2(unpack(hex_to_pixel(x, y, layout))))
^ am.text(string.format("%d, %d", x, y)))
am.delay(1)
test_scene:remove_all("text")
test_scene:append(am.translate(vec2(unpack(hex_to_pixel(x, y, layout)))) ^ am.text(string.format("%d, %d", x, y)))
end)
Loading…
Cancel
Save