nickhayashi
/
hexyz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

testing menus

master
churchianity 5 years ago
parent
ea47466c64
commit
76a43946de
2 changed files with 159 additions and 98 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 46
      src/hexyz.lua
  2. 209
      src/main.lua

46
src/hexyz.lua
View File

@ -3,9 +3,9 @@
local function round(n) return n % 1 >= 0.5 and math.ceil(n) or math.floor(n) end local function round(n) return n % 1 >= 0.5 and math.ceil(n) or math.floor(n) end
--[[============================================================================ --[[============================================================================
----- HEX CONSTANTS AND UTILITY FUNCTIONS -----
============================================================================]]--
-- HEX CONSTANTS AND UTILITY FUNCTIONS
]]
-- All Non-Diagonal Vector Directions from a Given Hex by Edge -- All Non-Diagonal Vector Directions from a Given Hex by Edge
HEX_DIRECTIONS = {vec2( 1 , -1), vec2( 1 , 0), vec2(0 , 1), HEX_DIRECTIONS = {vec2( 1 , -1), vec2( 1 , 0), vec2(0 , 1),
vec2(-1 , 1), vec2(-1 , 0), vec2(0 , -1)} vec2(-1 , 1), vec2(-1 , 0), vec2(0 , -1)}
@ -48,11 +48,10 @@ local function hex_round(x, y, z)
rz = -rx - ry end rz = -rx - ry end
return vec2(rx, ry) return vec2(rx, ry)
end end
--[[==========================================================================-- --[[==========================================================================--
----- ORIENTATION & LAYOUT -----
============================================================================]]--
-- ORIENTATION & LAYOUT
]]
-- Forward & Inverse Matrices used for the Flat Orientation -- Forward & Inverse Matrices used for the Flat Orientation
local FLAT = {M = mat2(3.0/2.0, 0.0, 3.0^0.5/2.0, 3.0^0.5 ), local FLAT = {M = mat2(3.0/2.0, 0.0, 3.0^0.5/2.0, 3.0^0.5 ),
W = mat2(2.0/3.0, 0.0, -1.0/3.0 , 3.0^0.5/3.0), W = mat2(2.0/3.0, 0.0, -1.0/3.0 , 3.0^0.5/3.0),
@ -64,11 +63,11 @@ local POINTY = {M = mat2(3.0^0.5, 3.0^0.5/2.0, 0.0, 3.0/2.0),
angle = 0.5} angle = 0.5}
-- Hex to Screen -- Orientation Must be Either POINTY or FLAT -- Hex to Screen -- Orientation Must be Either POINTY or FLAT
function hex_to_pixel(hex, size, orientation_M, offset)
function hex_to_pixel(hex, size, orientation_M)
local M = orientation_M or FLAT.M local M = orientation_M or FLAT.M
local x = (M[1][1] * hex[1] + M[1][2] * hex[2]) * size[1]
local y = (M[2][1] * hex[1] + M[2][2] * hex[2]) * size[2]
local x = (M[1][1] * hex[1] + M[1][2] * hex[2]) * (size and size[1] or 11)
local y = (M[2][1] * hex[1] + M[2][2] * hex[2]) * (size and size[2] or 11)
return vec2(x, y) return vec2(x, y)
end end
@ -78,7 +77,7 @@ end
function pixel_to_hex(pix, size, orientation_W) function pixel_to_hex(pix, size, orientation_W)
local W = orientation_W or FLAT.W local W = orientation_W or FLAT.W
local pix = pix / size
local pix = pix / (size or vec2(11))
local x = W[1][1] * pix[1] + W[1][2] * pix[2] local x = W[1][1] * pix[1] + W[1][2] * pix[2]
local y = W[2][1] * pix[1] + W[2][2] * pix[2] local y = W[2][1] * pix[1] + W[2][2] * pix[2]
@ -111,15 +110,14 @@ function hex_to_offset(hex)
return vec2(hex[1], -hex[1] - hex[2] + (hex[1] + (hex[1] % 2)) / 2) end return vec2(hex[1], -hex[1] - hex[2] + (hex[1] + (hex[1] % 2)) / 2) end
-- ... Back to Cube Coordinates
-- Back to Cube Coordinates
function offset_to_hex(off) function offset_to_hex(off)
return vec2(off[1], off[2] - math.floor((off[1] - 1 * (off[1] % 2))) / 2) end return vec2(off[1], off[2] - math.floor((off[1] - 1 * (off[1] % 2))) / 2) end
--[[============================================================================ --[[============================================================================
----- MAPS & STORAGE -----
============================================================================]]--
-- MAPS & STORAGE
]]
-- Returns Ordered Ring-Shaped Map of |radius| from |center| -- Returns Ordered Ring-Shaped Map of |radius| from |center|
function ring_map(center, radius) function ring_map(center, radius)
local map = {} local map = {}
@ -149,23 +147,13 @@ function spiral_map(center, radius)
end end
function hash_retrieve(map, entry)
for k,v in pairs(map) do
if k == entry then
return v
end
end
return nil
end
-- Returns Unordered Parallelogram-Shaped Map of |width| and |height| with Simplex Noise -- Returns Unordered Parallelogram-Shaped Map of |width| and |height| with Simplex Noise
function parallelogram_map(width, height, seed) function parallelogram_map(width, height, seed)
local seed = seed or math.random(width * height) local seed = seed or math.random(width * height)
local map = {} local map = {}
for i = 0, width do for i = 0, width do
map[i] = {}
for j = 0, height do for j = 0, height do
-- Calculate Noise -- Calculate Noise
@ -179,7 +167,7 @@ function parallelogram_map(width, height, seed)
local pos = vec2(idelta + seed * width, jdelta + seed * height) local pos = vec2(idelta + seed * width, jdelta + seed * height)
noise = noise + f * math.simplex(pos * l) noise = noise + f * math.simplex(pos * l)
end end
map[vec2(i, j)] = noise
map[i][j] = noise
end end
end end
setmetatable(map, {__index={width=width, height=height, seed=seed}}) setmetatable(map, {__index={width=width, height=height, seed=seed}})
@ -193,6 +181,7 @@ function triangular_map(size, seed)
local map = {} local map = {}
for i = 0, size do for i = 0, size do
map[i] = {}
for j = size - i, size do for j = size - i, size do
-- Generate Noise -- Generate Noise
@ -206,7 +195,7 @@ function triangular_map(size, seed)
local pos = vec2(idelta + seed * size, jdelta + seed * size) local pos = vec2(idelta + seed * size, jdelta + seed * size)
noise = noise + f * math.simplex(pos * l) noise = noise + f * math.simplex(pos * l)
end end
map[vec2(i, j)] = noise
map[i][j] = noise
end end
end end
setmetatable(map, {__index={size=size, seed=seed}}) setmetatable(map, {__index={size=size, seed=seed}})
@ -220,6 +209,8 @@ function hexagonal_map(radius, seed)
local map = {} local map = {}
for i = -radius, radius do for i = -radius, radius do
map[i] = {}
local j1 = math.max(-radius, -i - radius) local j1 = math.max(-radius, -i - radius)
local j2 = math.min(radius, -i + radius) local j2 = math.min(radius, -i + radius)
@ -234,9 +225,10 @@ function hexagonal_map(radius, seed)
local f = 2/3^oct local f = 2/3^oct
local l = 2^oct local l = 2^oct
local pos = vec2(idelta + seed * radius, jdelta + seed * radius) local pos = vec2(idelta + seed * radius, jdelta + seed * radius)
noise = noise + f * math.simplex(pos * l) noise = noise + f * math.simplex(pos * l)
end end
map[vec2(i, j)] = noise
map[i][j] = noise
end end
end end
setmetatable(map, {__index={radius=radius, seed=seed}}) setmetatable(map, {__index={radius=radius, seed=seed}})

209
src/main.lua
View File

@ -2,30 +2,30 @@
require"hexyz" require"hexyz"
math.randomseed(os.time()); math.random(); math.random(); math.random() math.randomseed(os.time()); math.random(); math.random(); math.random()
--[[============================================================================
function explosion(position, size, color, color_var, sound) end
]]
--
win = am.window win = am.window
{ -- Base Resolution = 3/4 * WXGA standard 16:10
width = 1280 * 3/4, height = 800 * 3/4, -- 960px -- 600px
}
bias = "right"
state = {
score = 0,
{ -- Base Resolution = 3/4 * WXGA standard 16:10 -- 960px, 600px
width = 1280 * 3/4, height = 800 * 3/4,
clear_color = vec4(0.08, 0.08, 0.11, 1)
} }
local map local map
local world
local home local home
local home_node
local spawn_chance = 25
--[[============================================================================
]]
-- ensure home-base is somewhat of an open area. -- ensure home-base is somewhat of an open area.
function find_home(preferred_radius) function find_home(preferred_radius)
home = spiral_map(vec2(23, 4), preferred_radius or 2) home = spiral_map(vec2(23, 4), preferred_radius or 2)
home_node = am.group()
local home_node = am.group()
repeat repeat
local happy = true local happy = true
@ -42,7 +42,7 @@ function find_home(preferred_radius)
home_node = am.group() home_node = am.group()
else else
local center = hex_to_pixel(h, vec2(11))
local center = hex_to_pixel(h)
local color = vec4(1, 0, 0.5, 1) local color = vec4(1, 0, 0.5, 1)
local node = am.circle(center, 4, color, 4) local node = am.circle(center, 4, color, 4)
home_node:append(node) home_node:append(node)
@ -55,26 +55,25 @@ end
-- map elevation to appropriate tile color. -- map elevation to appropriate tile color.
function color_at(elevation) function color_at(elevation)
if elevation < -0.5 then -- Lowest Elevation : Impassable
if elevation < -0.5 then -- lowest elevation : impassable
return vec4(0.10, 0.30, 0.40, (elevation + 1.4) / 2 + 0.2) return vec4(0.10, 0.30, 0.40, (elevation + 1.4) / 2 + 0.2)
elseif elevation < 0 then -- Med-Low Elevation : Passable
elseif elevation < 0 then -- med-low elevation : passable
return vec4(0.10, 0.25, 0.10, (elevation + 1.8) / 2 + 0.2) return vec4(0.10, 0.25, 0.10, (elevation + 1.8) / 2 + 0.2)
elseif elevation < 0.5 then -- Med-High Elevation : Passable
elseif elevation < 0.5 then -- med-high elevation : passable
return vec4(0.25, 0.20, 0.10, (elevation + 1.6) / 2 + 0.2) return vec4(0.25, 0.20, 0.10, (elevation + 1.6) / 2 + 0.2)
elseif elevation < 1 then -- Highest Elevation : Impassable
elseif elevation < 1 then -- highest elevation : impassable
return vec4(0.15, 0.30, 0.20, (elevation + 1.0) / 2 + 0.2) return vec4(0.15, 0.30, 0.20, (elevation + 1.0) / 2 + 0.2)
else
return vec4(0.6)
end end
end end
function cartograph()
map = rectangular_map(46, 33); math.randomseed(map.seed)
world = am.translate(vec2(-278, -318)) ^ am.group():tag"world"
--
function random_map(seed)
map = rectangular_map(46, 33, seed); math.randomseed(map.seed)
local world = am.translate(vec2(-278, -318)) ^ am.group():tag"world"
for i,_ in pairs(map) do for i,_ in pairs(map) do
for j,elevation in pairs(map[i]) do for j,elevation in pairs(map[i]) do
@ -85,21 +84,20 @@ function cartograph()
((-off.y - 16.5) / 32) ^ 2)) ((-off.y - 16.5) / 32) ^ 2))
local color = color_at(elevation) - mask local color = color_at(elevation) - mask
local node = am.circle(hex_to_pixel(vec2(i, j), vec2(11)), 11, vec4(0), 6)
:action(am.tween(1, {color=color}, am.ease.out(am.ease.hyperbola)))
local node = am.circle(hex_to_pixel(vec2(i, j)), 11, vec4(0), 6)
:action(am.tween(2, {color=color}, am.ease.out(am.ease.hyperbola)))
world:append(node) world:append(node)
end end
end end
world:append(find_home())
world:append(find_home(2))
world:action(spawner) world:action(spawner)
return world
return world:tag"world"
end end
-- determines when, where, and how often to spawn mobs. -- determines when, where, and how often to spawn mobs.
function spawner(world) function spawner(world)
if math.random(25) == 1 then -- chance to spawn
if math.random(spawn_chance) == 1 then -- chance to spawn
local spawn_position local spawn_position
repeat repeat
-- ensure we spawn on an random tile along the map's edges -- ensure we spawn on an random tile along the map's edges
@ -115,13 +113,7 @@ function spawner(world)
local e = map[spawn_position.x][spawn_position.y] local e = map[spawn_position.x][spawn_position.y]
until e and e < 0.5 and e > -0.5 until e and e < 0.5 and e > -0.5
local mob
if bias == "right" then
mob = am.translate(-278, -318) ^ am.circle(hex_to_pixel(spawn_position, vec2(11)), 4)
elseif bias == "left" then
mob = am.translate(-480, -318) ^ am.circle(hex_to_pixel(spawn_position, vec2(11)), 4)
end
local mob = am.translate(-278, -318) ^ am.circle(hex_to_pixel(spawn_position), 4)
world:append(mob"circle":action(coroutine.create(live))) world:append(mob"circle":action(coroutine.create(live)))
end end
end end
@ -131,11 +123,12 @@ end
function live(mob) function live(mob)
local dead = false local dead = false
local visited = {}; visited[mob.center] = true
local visited = {}
visited[mob.center.x] = {}; visited[mob.center.x][mob.center.y] = true
-- begin life -- begin life
repeat repeat
local neighbours = hex_neighbours(pixel_to_hex(mob.center, vec2(11)))
local neighbours = hex_neighbours(pixel_to_hex(mob.center))
local candidates = {} local candidates = {}
-- get list of candidates: hex positions to consider moving to. -- get list of candidates: hex positions to consider moving to.
@ -147,7 +140,11 @@ function live(mob)
end end
if e and e < 0.5 and e > -0.5 then if e and e < 0.5 and e > -0.5 then
if not hash_retrieve(visited, h) then
if visited[h.x] then
if not visited[h.x][h.y] then
table.insert(candidates, h)
end
else
table.insert(candidates, h) table.insert(candidates, h)
end end
end end
@ -165,62 +162,134 @@ function live(mob)
end -- bug end -- bug
local speed = map[move.x][move.y] ^ 2 + 0.5 local speed = map[move.x][move.y] ^ 2 + 0.5
am.wait(am.tween(mob, speed, {center=hex_to_pixel(move, vec2(11))}))
visited[move] = true
am.wait(am.tween(mob, speed, {center=hex_to_pixel(move)}))
visited[move.x] = {}; visited[move.x][move.y] = true
if move == home.center then dead = true end if move == home.center then dead = true end
until dead until dead
explosion(mob.center)
win.scene:remove(mob)
end end
--
function init()
local score = am.translate(-264, 290) ^ am.text("0", "left"):tag"score"
local coords = am.translate(440, 290) ^ am.text():tag"coords"
local bg = am.rect(win.left, win.top, win.right, win.bottom, vec4(0.12, 0.3, 0.3, 1)):tag"curtain"
-- -480, 300, -268, -300
main_scene = am.group
{
cartograph(),
bg,
score,
coords,
}
main_scene:append(am.circle(home.center, 11, vec4(0.4), 6):tag"selected")
function main_action(scene)
-- POLL MOUSE
function poll_mouse()
if win:mouse_position().x > -268 then -- mouse is inside game map
-- get info about mouse position -- get info about mouse position
local hex = pixel_to_hex(win:mouse_position() - vec2(-278, -318), vec2(11))
local hex = pixel_to_hex(win:mouse_position() - vec2(-278, -318))
local off = hex_to_offset(hex) local off = hex_to_offset(hex)
-- check if cursor location outside of map bounds -- check if cursor location outside of map bounds
if map[hex.x] == nil or map[hex.x][hex.y] == nil or off.x <= 1 or -off.y <= 1 or off.x >= 46 or -off.y >= 32 then
scene"coords".text = ""
if off.x <= 1 or -off.y <= 1 or off.x >= 46 or -off.y >= 32 then
win.scene"coords".text = ""
else else
-- check if mouse clicked
if win:mouse_down"left" then
if win:mouse_down"left" then -- check if mouse clicked
if map[hex.x][hex.y] <= -0.5 or map[hex.x][hex.y] >= 0.5 then if map[hex.x][hex.y] <= -0.5 or map[hex.x][hex.y] >= 0.5 then
else else
map[hex.x][hex.y] = 2 map[hex.x][hex.y] = 2
world:append(am.circle(hex_to_pixel(hex, vec2(11)), 11, vec4(0.2, 0.2, 0.2, 1), 6))
win.scene"world":append(am.circle(hex_to_pixel(hex), 11, vec4(0, 0, 0, 1), 6))
end
end
win.scene"coords".text = string.format("%2d,%2d", off.x, -off.y)
win.scene"selected".center = hex_to_pixel(hex) + vec2(-278, -318)
end
else -- mouse is over background bar, (or outside window!!!!)
if win:key_pressed"escape" then
init()
end
end
end
--
function update_score()
win.scene"score".text = string.format("SCORE: %.2f", am.current_time())
end
function update_mobs()
end end
--
function button(x, y)
local color = (x + y) % 2 == 0 and vec4(0.4, 0.4, 0.5, 1) or vec4(0.5, 0.4, 0.4, 1)
return am.translate(x * 80, y * 80) ^ am.rect(-40, 40, 40, -40, color)
end end
scene"coords".text = string.format("%d,%d", off.x, -off.y)
scene"selected".center = hex_to_pixel(hex, vec2(11)) + vec2(-278, -318)
-- GAME INITIALIZATION FUNCTION
function game_init()
local score = am.translate(-264, 290) ^ am.text("", "left"):tag"score"
local coords = am.translate(440, 290) ^ am.text(""):tag"coords"
local selected = am.circle(vec2(win.left, win.top), 11, vec4(0.4), 6):tag"selected"
local bg = am.rect(win.left, win.top, win.right, win.bottom, vec4(0.12, 0.3, 0.3, 1)):tag"curtain"
local buttons = am.translate(-500, -300) ^ am.group()
for i = 1, 2 do
for j = 1, 6 do
buttons:append(button(i, j))
end end
scene"score".text = string.format("SCORE: %.2f", am.current_time() + state.score)
end end
main_scene:action(am.series
local main_scene = am.group{random_map(9), bg, buttons, score, coords, selected}
:action(am.series
{ {
am.tween(bg, 1, {x2 = -268}, am.ease.bounce),
main_action
am.tween(bg, 0.8, {x2 = -268}, am.ease.bounce), -- INTRO TRANSITION
function(scene) -- MAIN ACTION
update_score()
-- update mobs
-- update towers
-- update environment
poll_mouse() -- check if player did anything
end
}) })
win.scene = main_scene win.scene = main_scene
end end
-- TITLE SCREEN
function init()
local map = hexagonal_map(15, 9)
local backdrop = am.group()
for i,_ in pairs(map) do
for j,e in pairs(map[i]) do
backdrop:append(am.circle(hex_to_pixel(vec2(i, j)), 11, color_at(e), 6))
end
end
local title_text = am.group
{
am.translate(0, 200) ^ am.scale(5) ^ am.text("hexyz", vec4(0.8, 0.8, 0.7, 1), "right"),
am.translate(0, 130) ^ am.scale(4) ^ am.text("a tower defense", vec4(0.8, 0.8, 0.7, 1)),
am.circle(vec2(0), 100, vec4(0.6), 6):tag"b", am.scale(4) ^ am.text("START", vec4(0, 0, 0, 1))
}
win.scene = am.group
{
backdrop,
title_text
}
:action(function(s)
local mouse = win:mouse_position()
if math.length(mouse) < 100 then
s"b":action(am.series
{
am.tween(0.1, {color = vec4(0.8, 0.8, 0.7, 1)}),
am.tween(0.1, {color = vec4(0.6)})
})
if win:mouse_pressed"left" then
game_init()
end
end
end)
end
init() init()
noglobals()
Write Preview
Loading…
Cancel
Save