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

Merge branch 'master' of github.com:churchianity/wz 

deleted files that were added erroneously
master
churchianity 6 years ago
parent
7ea54c123b 5365d38553
commit
1be729a077
3 changed files with 0 additions and 266 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 164
      '
  2. 67
      ;
  3. 35
      Warzone2gdd

164
'
View File

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

67
;
View File

@ -1,67 +0,0 @@
----- [[ 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()

35
Warzone2gdd
View File

@ -1,35 +0,0 @@
Warzone 2 is a concept for a browser-based, hexagonal grid tower defense game.
The working title is informal and will be changed.
It comes from a browser flash game called Warzone Tower Defense.
Javascript, html5 Canvas will be the host.
Concept:
In warzone tower defense (the original), the most powerful tower you can
purchase is the wall block. It isn't a proper tower at 1/4 the real-estate -
not to mention the fact it does not have offensive capabilities. The best
strategy revolves around figuring out the optimal defensive structure to erect
with wall blocks. Warzone 2 wants to continue with this strong gameplay theme
of the construction of defensive structures. This differs from the typical
tower defense in that the towers really aren't the primary focus. The focus
is the landscape + defensive structre on and around which you build the towers.
Supporting this theme is a hexagonal 2D grid - 3D would be too avant-garde.
Having 50% more directional choice for units will in theory make for much more
interesting defensive structures. Along with it is random map generation.
Hex tiles will have a variety of properties:
- Height Level [-2 .. 2]
Tiles can be raised or lowered relative to others. This will effect
building, towers, enemy pathing and more.
- Plot
Tiles can contain natural resources or hazards on top of its natural
texture.
-
Write Preview
Loading…
Cancel
Save