local VERSION = '1.0.2 - models are now exported to the DB upon saving'
os.loadAPI('tracker')
os.loadAPI('json')

print("Starting 20.000 Blocks")

DEBUG_MODE = false
local monitor = peripheral.wrap("right")
local ox,oy,oz = commands.getBlockPosition()

CITY_VERSION = 1 -- this denotes which iteration of the map is current. When the map is full, i.e. all buildzones have been played we replace it with an empty one and increase the city vesrion with 1
SPAWN_VILLAGER = false
DO_GRID = true --this refers to the grid of detector blocks placed on the ground at the start of each new game
GRIDCELL_SIZE = 9 -- the width of one grid cell in minecraft blocks. MUST BE ODD NUMBER
GRIDCELL_COUNT = 7 -- the number of gridcells or slots across X and Z in one game. for IBA_GAME it is 7x7
PLUG_LENGTH = 3 -- the number of minecraft blocks which the crosses arround each detector block that are made out of plug blocks will expand to
GRID_HOLE_CHANCE = 0
NUMBER_OF_BUILDZONES = 6
NUMBER_OF_VOCAB = 10
PHASE_LENGTH_GAME = 600 --seconds a game lasts
PHASE_LENGTH_WAIT = 15 --seconds to wait for players to stand in the yeloow box before starting a game
PHASE_LENGTH_OVER = 15 --seconds to wait after a game is completing befor setting the buildzone to the next phase
VOCAB_WIDTH = 27
VOCAB_HEIGHT = 19
BUILDZONE_WIDTH = 62 -- the actual zone width is 63 blocks, but for some reason due to how minecraft handles relative coordinates this has to be 62
BUILDZONE_FLOOR_HEIGHT = -1
HOMECOMER_TYPE = "Pig"
HOMECOMER_VALUE = 90 --90 is for pig
MAX_PLAYERS_PER_GAME = 4
MIN_BUILDINGS = 5 -- the minimum number of buildings a buildzone must have in order to be saved and no discarded at the end of a game

SPAWN = {
	x=12110,
	y=57,
	z=-1777,
	a1=90,
	a2=0
	}
FIRSTZONE= {
	x=11685,
	y=57,
	z=-1869
	}
WAITZONE = {
	x=12093,
	y=56,
	z=-1779,
	w=5,
	l=5
	}
--this is the block at ~-4 ~ ~-4 from the corner of the shape zone
--i.e., (the one with the grammar shape in it) of the vocab that is closest to zero
FIRSTVOCAB= {
	x=0,
	y=57,
	z=5
}
--VICTORY_HEIGHT = 30
--VICTORY_TOTAL = 50
--VICTORY_SPECIFIC = {name='garden',count=101}


WOOL_PER_EMERALD = 64


BLOCKS = {
	CAMP_FLOOR = {block='minecraft:sandstone',data=0},
	CONSTRUCTION = {block='minecraft:diamond_ore',data=0},
	RING = {block='minecraft:diamond_ore',data=0},
	DETECT = {block='minecraft:red_sandstone',data=0},
	DETECT_DEAD = {block='minecraft:obsidian',data=0},
	VOCAB_DETECT = {block="minecraft:quartz_block",data=0},
	VOCAB_REPLACE = {block="minecraft:coal_block",data=0},
	VICTORY_MARKER = {block="minecraft:emerald_block",data=0},
	PLUG = {block="minecraft:lapis_ore",data=0},
	PHVFLOOR = {block="minecraft:stone_slab",data=3},
	BUILDING_HOUSE = {block="minecraft:wool",data=0},
	BUILDING_GARDEN = {block="minecraft:wool",data=13},
	BUILDING_WATER = {block="minecraft:wool",data=1},
	_matWhiteSmooth ={block="mincreaft:stained_hardened_clay",data=0},
	_matWhiteSmooth2 = {block="minecraft:brick_block",data=0},
	_matYellowSmooth = {block="minecraft:stained_hardened_clay",data=4},
	_matPinkSmooth = {block="minecraft:stained_hardened_clay",data=6},
	_matBlueSmooth = {block="minecraft:stained_hardened_clay",data=9},
	_matPurpleSmooth = {block="minecraft:stained_hardened_clay",data=10},
	_matWhiteTextured = {block="minecraft:planks",data=4},
	_matYellowTextured = {block="minecraft:planks",data=1},
	_matPinkTextured = {block="minecraft:planks",data=0},
	_matBlueTextured = {block="minecraft:planks",data=2},
	_matPurpleTextured = {block="minecraft:planks",data=5},
	}

--contains a list of all posible Buildzones (build a bit later)
LOCS = {}

if DEBUG_MODE then
	PHASE_LENGTH_GAME = 12000
	NUMBER_OF_BUILDZONES = 1
end

-- see if the file exists
function file_exists(file)
  local f = fs.open(file, "rb")
  if f then f:close() end
  return f ~= nil
end

--creates a grid of absolute references (0,0) (1,0)
function buildGrid(w,h)
	local grid = readGridFromFile()
	if grid then
		-- grid was read from the file successfully
	else
		--generate file from scratch
		grid = {}
		for z=0,h-1 do
			for x=0,w-1 do
				table.insert(grid,{x=x,z=z,played=false})
			end
		end
	end
	return grid
end

function readGridFromFile()
	local result = nil
	fs.makeDir("/records")
	if DEBUG_MODE then
		local filename = "/records/_buildzones-list-debug-area.yaml"
	else
		local filename = "/records/_buildzones-list.yaml"
	end if
	if file_exists(filename) then
		---read from file
		result = json.decodeFromFile(filename)
	end
	return result
end

function writeGridToFile()
	fs.makeDir("/records")
	--local filename = "/records/_buildzones-list.yaml"
	if DEBUG_MODE then
		local filename = "/records/_buildzones-list-debug-area.yaml"
	else
		local filename = "/records/_buildzones-list.yaml"
	end if
	local file = fs.open(filename,"w")
	file.write(json.encodePretty(LOCS))
	file.close()
end

--sets where and how big the PHV area is
--second number is along the long edge of PHV starting at the spawn side
--first number is along the short edge of PHV starting from the park side
if DEBUG_MODE then
	FIRSTZONE= {
	x=5,
	y=57,
	z=-7
	}

	LOCS = buildGrid(1,3)
else
	LOCS = buildGrid(11,27)
end

--call these to return a proper minecraft item string including adventure mode properties
function houseBlock(quant)
	text = BLOCKS.BUILDING_HOUSE.block..' '..quant..' '..BLOCKS.BUILDING_HOUSE.data..' {display:{Name:"Urban Resource",Lore:[Place this against a Detector to build denser, more urban buildings]},CanPlaceOn:["'..BLOCKS.BUILDING_HOUSE.block..'","'..BLOCKS.PLUG.block..'","'..BLOCKS.DETECT.block..'"]}'
	return text
end


function gardenBlock(quant)
	text = BLOCKS.BUILDING_GARDEN.block..' '..quant..' '..BLOCKS.BUILDING_GARDEN.data..' {display:{Name:"Nature Resource",Lore:[Place this against a Detector to build greener, more open buildings]},CanPlaceOn:["'..BLOCKS.BUILDING_HOUSE.block..'","'..BLOCKS.PLUG.block..'","'..BLOCKS.DETECT.block..'"]}'
	return text
end

PICKAXE_USES = 40
pickaxe = 'stone_pickaxe 1 '..131-PICKAXE_USES..' {CanDestroy:["'..BLOCKS.BUILDING_HOUSE.block..'"],display:{Name:"Resource Remover",Lore:[Use the pickaxe to remove up to '..PICKAXE_USES..' resource blocks]}}'



STARTING_ITEMS = {
	houseBlock(30), gardenBlock(30),pickaxe
}


DEFAULT_NAME = 'BUILDING'
--[[
VOCAB_NAMES = {
	'freestand-house',
	'freestand-house',
	'freestand-house',
	'freestand-house',
	'dbl-ext-house',
	'dbl-ext-house',
	'dbl-ext-house',
	'dbl-ext-house',
	'bridge-house',
	'bridge-house',
	'bridge-garden',
	'bridge-garden',
	'ext-house',
	'ext-house',
	'ext-house',
	'ext-house',
	'riser-1',
	'riser-2',
	'city-garden',
	'city-plaza',
	'dbl-ext-garden',
	'dbl-ext-garden',
	'dbl-ext-garden',
	'dbl-ext-garden',
	'ext-garden',
	'ext-garden',
	'ext-garden',
	'ext-garden',
	'corner-garden',
	'corner-garden',
	'corner-garden',
	'corner-garden',
	'corner-house',
	'corner-house',
	'corner-house',
	'corner-house',
	'freestand-garden',
	'freestand-garden',
	'freestand-garden',
	'freestand-garden'
	}
--]]


----------------------------------------------------------------------------------------------------------------
-- the data structure below represents the catalogue of vocabularies as built in minecraft
-- id - is unique for each vocab, starting from 1 going to 40 currently
-- column and row - represent the "physical" location of the vocab model in the catalogue in the minecraft world
-- nameEN and name DE - are names for english and german. for now english names must not have spaces, use dashes (-) instead
-- typeEN and typeDE - are the type names, also in english and german such as tech&science spaces
-- height - is how many blocks is this structure tall
-- slots - is how many potential detector stones is this structure occupying as a building, ex. 2 for houses, 3 for corner extenstions, 0 for plazas
-- green - is true or false and is used for easier calculation of the GREENEST GOAL - we dont use this field now and can be removed
-- greenSlots - is how many slots are green and is used for easier calculation of the GREENEST GOAL
VOCABS_DATA = {
	-- urban houses
	{id=1, column=1, row=1,nameEN="SINGLE-FAMILY-HOUSE",nameDE="EINFAMILIENHAUS", typeEN="HOUSES",typeDE="HÄUSER",height=10, slots=2, green=false, greenSlots=0, rewardUrban=false, rewardCount=4},
	{id=2, column=1, row=2,nameEN="SINGLE-FAMILY-HOUSE",nameDE="EINFAMILIENHAUS", typeEN="HOUSES",typeDE="HÄUSER",height=10, slots=2, green=false, greenSlots=0, rewardUrban=false, rewardCount=4},
	{id=3, column=1, row=3,nameEN="SINGLE-FAMILY-HOUSE",nameDE="EINFAMILIENHAUS", typeEN="HOUSES",typeDE="HÄUSER",height=10, slots=2, green=false, greenSlots=0, rewardUrban=false, rewardCount=4},
	{id=4, column=1, row=4,nameEN="SINGLE-FAMILY-HOUSE",nameDE="EINFAMILIENHAUS", typeEN="HOUSES",typeDE="HÄUSER",height=10, slots=2, green=false, greenSlots=0, rewardUrban=false, rewardCount=4},
	-- urban businesses
	{id=5, column=2, row=1,nameEN="GYM",nameDE="FITNESSSTUDIO", typeEN="BUSINESSES",typeDE="GESCHÄFTE",height=20, slots=5, green=false, greenSlots=0, rewardUrban=false, rewardCount=8},
	{id=6, column=2, row=2,nameEN="OFFICE-BUILDING",nameDE="BÜROGEBÄUDE", typeEN="BUSINESSES",typeDE="GESCHÄFTE",height=20, slots=5, green=false, greenSlots=0, rewardUrban=false, rewardCount=8},
	{id=7, column=2, row=3,nameEN="HOTEL",nameDE="HOTEL", typeEN="BUSINESSES",typeDE="GESCHÄFTE",height=20, slots=5, green=false, greenSlots=0, rewardUrban=false, rewardCount=8},
	{id=8, column=2, row=4 ,nameEN="BANK",nameDE="BANK", typeEN="BUSINESSES",typeDE="GESCHÄFTE",height=20, slots=5, green=false, greenSlots=0, rewardUrban=false, rewardCount=8},
	-- urban tech&science spaces
	{id=9, column=3, row=1,nameEN="LIBRARY",nameDE="BIBLIOTHEK", typeEN="TECH & SCIENCE SPACES",typeDE="WISSENSCHAFTSGEBÄUDE",height=16, slots=1, green=false, greenSlots=0, rewardUrban=false, rewardCount=10},
	{id=10, column=3, row=2,nameEN="FABLAB",nameDE="INNOVATIONSZENTRUM", typeEN="TECH & SCIENCE SPACES",typeDE="WISSENSCHAFTSGEBÄUDE",height=16, slots=1, green=false, greenSlots=0, rewardUrban=false, rewardCount=10},
	-- green tech&science spaces
	{id=11, column=3, row=3,nameEN="AQUAPONIC-GREENHOUSE",nameDE="AQUAPONIK-GEWÄCHSHAUS", typeEN="TECH & SCIENCE SPACES",typeDE="WISSENSCHAFTSGEBÄUDE",height=16, slots=1, green=true, greenSlots=1, rewardUrban=true, rewardCount=10},
	{id=12, column=3, row=4,nameEN="SCIENCE-BRIDGE",nameDE="WISSENSCHAFTSBRÜCKE", typeEN="TECH & SCIENCE SPACES",typeDE="WISSENSCHAFTSGEBÄUDE",height=16, slots=1, green=true, greenSlots=1, rewardUrban=true, rewardCount=10},
	-- urban house extensions
	{id=13, column=4, row=1,nameEN="HOUSE-EXTENSION",nameDE="HAUSERWEITERUNG", typeEN="EXTENSIONS",typeDE="ERWEITERUNGEN",height=10, slots=1, green=false, greenSlots=0, rewardUrban=false, rewardCount=6},
	{id=14, column=4, row=2,nameEN="HOUSE-EXTENSION",nameDE="HAUSERWEITERUNG", typeEN="EXTENSIONS",typeDE="ERWEITERUNGEN",height=10, slots=1, green=false, greenSlots=0, rewardUrban=false, rewardCount=6},
	{id=15, column=4, row=3,nameEN="HOUSE-EXTENSION",nameDE="HAUSERWEITERUNG", typeEN="EXTENSIONS",typeDE="ERWEITERUNGEN",height=10, slots=1, green=false, greenSlots=0, rewardUrban=false, rewardCount=6},
	{id=16, column=4, row=4,nameEN="HOUSE-EXTENSION",nameDE="HAUSERWEITERUNG", typeEN="EXTENSIONS",typeDE="ERWEITERUNGEN",height=10, slots=1, green=false, greenSlots=0, rewardUrban=false, rewardCount=6},
	--risers
	{id=17, column=5, row=1,nameEN="DOUBLE-FLOOR-RISER",nameDE="VERSCHIEBUNG-ZWEI-HOCH", typeEN="RISERS",typeDE="VERTIKALE VERSCHIEBUNGEN",height=0, slots=0, green=false, greenSlots=0, rewardUrban=true, rewardCount=8},
	{id=18, column=5, row=2,nameEN="SINGLE-FLOOR-RISER",nameDE="VERSCHIEBUNG-EINEN-HOCH", typeEN="RISERS",typeDE="VERTIKALE VERSCHIEBUNGEN",height=0, slots=0, green=false, greenSlots=0, rewardUrban=true, rewardCount=6},
	--plazas
	{id=19, column=5, row=3,nameEN="CITY-PLAZA",nameDE="STÄDTISCHER PLATZ", typeEN="PLAZAS",typeDE="PLÄTZE",height=0, slots=0, green=false, greenSlots=0, rewardUrban=false, rewardCount=2},
	{id=20, column=5, row=4,nameEN="PARK-PLAZA",nameDE="GRÜNER PLATZ", typeEN="PLAZAS",typeDE="PLÄTZE",height=0, slots=0, green=true, greenSlots=1, rewardUrban=true, rewardCount=2},
	--green businesses
	{id=21, column=6, row=1,nameEN="GREEN-GYM",nameDE="GRÜNES FITNESSSTUDIO", typeEN="BUSINESSES",typeDE="GESCHÄFTE",height=20, slots=5, green=true, greenSlots=5, rewardUrban=true, rewardCount=8},
	{id=22, column=6, row=2,nameEN="GREEN-OFFICE-BUILDING",nameDE="GRÜNES BÜROGEBÄUDE", typeEN="BUSINESSES",typeDE="GESCHÄFTE",height=20, slots=5, green=true, greenSlots=5, rewardUrban=true, rewardCount=8},
	{id=23, column=6, row=3,nameEN="GREEN-HOTEL",nameDE="GRÜNES HOTEL", typeEN="BUSINESSES",typeDE="GESCHÄFTE",height=20, slots=5, green=true, greenSlots=5, rewardUrban=true, rewardCount=8},
	{id=24, column=6, row=4,nameEN="GREEN-BANK",nameDE="GRÜNES BANK", typeEN="BUSINESSES",typeDE="GESCHÄFTE",height=20, slots=5, green=true, greenSlots=5, rewardUrban=true, rewardCount=8},
	---green private garden extensions
	{id=25, column=7, row=1,nameEN="HOUSE-GARDEN",nameDE="PRIVATGARTEN", typeEN="EXTENSIONS",typeDE="ERWEITERUNGEN",height=0, slots=0, green=true, greenSlots=1, rewardUrban=true, rewardCount=6},
	{id=26, column=7, row=2,nameEN="HOUSE-GARDEN",nameDE="PRIVATGARTEN", typeEN="EXTENSIONS",typeDE="ERWEITERUNGEN",height=0, slots=0, green=true, greenSlots=1, rewardUrban=true, rewardCount=6},
	{id=27, column=7, row=3,nameEN="HOUSE-GARDEN",nameDE="PRIVATGARTEN", typeEN="EXTENSIONS",typeDE="ERWEITERUNGEN",height=0, slots=0, green=true, greenSlots=1, rewardUrban=true, rewardCount=6},
	{id=28, column=7, row=4,nameEN="HOUSE-GARDEN",nameDE="PRIVATGARTEN", typeEN="EXTENSIONS",typeDE="ERWEITERUNGEN",height=0, slots=0, green=true, greenSlots=1, rewardUrban=true, rewardCount=6},
	---green gathering spaces
	{id=29, column=8, row=1,nameEN="OPEN-AIR-CINEMA",nameDE="FREILUFTKINO", typeEN="GATHERING SPACES",typeDE="TREFFPUNKTE",height=8, slots=3, green=true, greenSlots=3, rewardUrban=true, rewardCount=9},
	{id=30, column=8, row=2,nameEN="OPEN-AIR-SWIMMING-POOL",nameDE="FREIBAD", typeEN="GATHERING SPACES",typeDE="TREFFPUNKTE",height=8, slots=3, green=true, greenSlots=3, rewardUrban=true, rewardCount=9},
	{id=31, column=8, row=3,nameEN="GREEN-CAFE",nameDE="GRÜNES CAFÉ", typeEN="GATHERING SPACES",typeDE="TREFFPUNKTE",height=8, slots=3, green=true, greenSlots=3, rewardUrban=true, rewardCount=9},
	{id=32, column=8, row=4,nameEN="PALM-TREE-HOUSE",nameDE="PALMENGARTEN", typeEN="GATHERING SPACES",typeDE="TREFFPUNKTE",height=8, slots=3, green=true, greenSlots=3, rewardUrban=true, rewardCount=9},
	----urban gathering spaces
	{id=33, column=9, row=1,nameEN="CINEMA",nameDE="KINO", typeEN="GATHERING SPACES",typeDE="TREFFPUNKTE",height=8, slots=3, green=false, greenSlots=0, rewardUrban=false, rewardCount=9},
	{id=34, column=9, row=2,nameEN="CONFERENCE-HALL",nameDE="KONFERENZHALLE", typeEN="GATHERING SPACES",typeDE="TREFFPUNKTE",height=8, slots=3, green=false, greenSlots=0, rewardUrban=false, rewardCount=9},
	{id=35, column=9, row=3,nameEN="CAFÉ",nameDE="CAFÉ", typeEN="GATHERING SPACES",typeDE="TREFFPUNKTE",height=8, slots=3, green=false, greenSlots=0, rewardUrban=false, rewardCount=9},
	{id=36, column=9, row=4,nameEN="ART-GALLERY",nameDE="KUNSTGALERIE", typeEN="GATHERING SPACES",typeDE="TREFFPUNKTE",height=8, slots=3, green=false, greenSlots=0, rewardUrban=false, rewardCount=9},
	---green-roof houses
	{id=37, column=10, row=1,nameEN="GREEN-ROOF-HOUSE",nameDE="GRÜNES EINFAMILIENHAUS", typeEN="HOUSES",typeDE="HÄUSER",height=10, slots=2, green=true, greenSlots=2, rewardUrban=true, rewardCount=4},
	{id=38, column=10, row=2,nameEN="GREEN-ROOF-HOUSE",nameDE="GRÜNES EINFAMILIENHAUS", typeEN="HOUSES",typeDE="HÄUSER",height=10, slots=2, green=true, greenSlots=2, rewardUrban=true, rewardCount=4},
	{id=39, column=10, row=3,nameEN="GREEN-ROOF-HOUSE",nameDE="GRÜNES EINFAMILIENHAUS", typeEN="HOUSES",typeDE="HÄUSER",height=10, slots=2, green=true, greenSlots=2, rewardUrban=true, rewardCount=4},
	{id=40, column=10, row=4,nameEN="GREEN-ROOF-HOUSE",nameDE="GRÜNES EINFAMILIENHAUS", typeEN="HOUSES",typeDE="HÄUSER",height=10, slots=2, green=true, greenSlots=2, rewardUrban=true, rewardCount=4},
}


DEFAULT_REWARD = houseBlock(4)

REWARDS = {}


--constructor for player object so that data structure is consistant
function newPlayerData(name,x,y,z)
	local p = {
		name = name,
		x=x,
		y=y,
		z=z
	}
	return p
end

--return a list of all players in the game world as player objects
local function getAllPos(selector)
	local result, message = commands.tp("@a["..selector.."]","~ ~ ~")
	local names = {}
	if result == true then
		for i,result in ipairs(message) do
			local wordpattern = "[^, ]+"
			local numberpattern = "[%-% ]%d+[%.]%d+"
			local words,numbers = {},{}

			for word in string.gmatch(result, wordpattern) do
    table.insert(words,word)
   end

			for number in string.gmatch(result, numberpattern) do table.insert(numbers,number) end

			local coords = {
				x = math.floor(numbers[1]),
				y = math.floor(numbers[2]),
				z = math.floor(numbers[3])
				}
			local name = words[2]
			table.insert(names,newPlayerData(name,coords.x,coords.y,coords.z))
			--print("Player Found - getAllPos")
		end
	end
	return names
end

--sort table by random
local function shuffleTable( t )
    local rand = math.random
    assert( t, "shuffleTable() expected a table, got nil" )
    local iterations = #t
    local j

    for i = iterations, 2, -1 do
        j = rand(i)
        t[i], t[j] = t[j], t[i]
    end
end

--returns a list of player objects containing all players who are standing on the given block, and who also are in the given selection
local function getAllOnBlockType(block,selector)
	local result, message = commands.exec("execute @a["..selector.."] ~ ~ ~ detect ~ ~-1 ~ "..block.." -1 tp @p[r=1] ~ ~ ~")
	local names = {}
	if result == true then
		for i,result in ipairs(message) do
			local wordpattern = "[^, ]+"
			local numberpattern = "[%-% ]%d+[%.]%d+"
			local words,numbers = {},{}

			for word in string.gmatch(result, wordpattern) do table.insert(words,word) end
			for number in string.gmatch(result, numberpattern) do table.insert(numbers,number) end

			if numbers[1] and numbers[2] and numbers[3] then
				local coords = {
					x = math.floor(numbers[1]),
					y = math.floor(numbers[2]),
					z = math.floor(numbers[3])
					}
				local name = words[2]
				table.insert(names,newPlayerData(name,coords.x,coords.y,coords.z))
				print("Found a player - getOnBlock")
			else
				print("Error: Coordinate Numbers were missing")
			end
		end
	end
	return names
end

--gives a player a HOMECOMER egg with their name on it. Removes all spawn eggs first
local function giveHomecomer(name)
	commands.clear(name,'spawn_egg')

	commands.give(name,'spawn_egg 1 '..HOMECOMER_VALUE..' {CanPlaceOn:["'..BLOCKS.PHVFLOOR.block..'","'..BLOCKS.CAMP_FLOOR.block..'","'..BLOCKS._matWhiteSmooth.block..'","'..BLOCKS._matWhiteSmooth2.block..'","'..BLOCKS._matYellowSmooth.block..'","'..BLOCKS._matPinkSmooth.block..'","'..BLOCKS._matBlueSmooth.block..'","'..BLOCKS._matPurpleSmooth.block..'","'..BLOCKS._matWhiteTextured.block..'","'..BLOCKS._matYellowTextured.block..'","'..BLOCKS._matPinkTextured.block..'","'..BLOCKS._matBlueTextured.block..'","'..BLOCKS._matPurpleTextured.block..'"],display:{Name:"HOMECOMER - '..name..'",Lore:[Use this on the floor to return to spawn]}}')
end

--returns a list of HOMECOMER entities and their names
local function getHomecomers()
	local result, message = commands.exec("execute @e[type="..HOMECOMER_TYPE.."] ~ ~ ~ tp @e[r=1] ~ ~ ~")
	local names = {}
	if result == true then
		for i,result in ipairs(message) do
			local wordpattern = "[^, ]+"
			local numberpattern = "[%-% ]%d+[%.]%d+"
			local words,numbers = {},{}

			for word in string.gmatch(result, wordpattern) do table.insert(words,word) print(word) end
			for number in string.gmatch(result, numberpattern) do table.insert(numbers,number) end

			if numbers[1] and numbers[2] and numbers[3] then
				local coords = {
					x = math.floor(numbers[1]),
					y = math.floor(numbers[2]),
					z = math.floor(numbers[3])
					}
				local name = words[4]
				table.insert(names,newPlayerData(name,coords.x,coords.y,coords.z))
				print("Found a player - getOnBlock "..name)
			else
				print("Error: Coordinate Numbers were missing")
			end
		end
	end
	return names
end

local function removePlayerFromKew(game,playername)
	for _,kew in pairs(game.queues) do
		for index, player in ipairs(kew.playerlist) do
			if player.name == playername then
				table.remove(kew.playerlist,index)
			end
		end
		if #kew.playerlist == 0 and kew.phase == 2 then
			--game can be ended as no players are left
			kew.timer = 0
		end
	end
end

local function movePlayerToSpawn(playername)
	respawnPlayer(playername)
	commands.async.tp(playername,SPAWN.x,SPAWN.y,SPAWN.z,SPAWN.a1,SPAWN.a2)
	commands.async.tellraw(playername,'["",{"text":"You used your HOMECOMER and TELEPORTED BACK TO SPAWN","color":"white"}]')
	commands.async.tellraw(playername,'["",{"text":"Du hast den HEIMKEHRER benutzt um dich zurück zum Anfang zu teleportieren.","color":"gold"}]')
end

--takes a list of homecomers and deals with all those players, moving them back to spawn and removing them from game
--also gives them a new homecomer
local function dealWithHomecomers(game, homecomers)
	for _,homecomer in pairs(homecomers) do
		--remove player from current game if in game
		removePlayerFromKew(game,homecomer.name)
		--teleport them back to spawn
		movePlayerToSpawn(homecomer.name)
		--give a new homecomer
		giveHomecomer(homecomer.name)
		--particle effects
		--teleport message
	end
	--kill all homecomers
	if #homecomers>0 then
		commands.tp("@e[type="..HOMECOMER_TYPE.."]",100000,200,100000)
		commands.kill("@e[type="..HOMECOMER_TYPE.."]")
		os.sleep(#homecomers*0.2)
	end
end




--creates a villager with special items
local function spawnVillager(x,y,z)
	commands.summon("Villager",x,y,z,'{Invulnerable:1,CustomName:Wool_Seller,Profession:2,Career:1,CareerLevel:6,Offers:{Recipes:[ {buy:{id:emerald,Count:1},sell:{id:wool,Count:'..WOOL_PER_EMERALD..',tag:{CanPlaceOn:["minecraft:diamond_block","minecraft:clay","minecraft:wool","minecraft:stained_hardened_clay"]}}}, {buy:{id:emerald,Count:1},sell:{id:stone_pickaxe,Count:1,Damage:'..131-PICKAXE_USES..',tag:{CanDestroy:["minecraft:wool"]}}}  ]}}')
end


--displays a time as experience points to a selection of players
local function displayTime(selector,minutes,seconds)
	--commands.title("@a["..selector.."]","subtitle",'{text:"Time left:  '..minutes..":"..seconds..'",color:red,bold:false,underlined:false,italic:false,strikethrough:false,obfuscated:false}')
	commands.async.xp("-1000000L","@a["..selector.."]")
	local secondstot = (minutes * 60) + seconds
	commands.async.xp(tostring(secondstot).."L","@a["..selector.."]")
end

--displays a title to a selection of players
local function displayTitle(selector,text)
	commands.async.title("@a["..selector.."]","title",'{text:"'..text..'"}')
end

--simply runs displayTitle on a list of players
local function displayTitleToGroup(playerlist,text)
	for i,player in ipairs(playerlist) do
		displayTitle("name="..player.name,text)
	end
end

--simply runs displayTime on a list of players
local function displayTimeToGroup(playerlist,minutes,seconds)
	for i,player in ipairs(playerlist) do
		displayTime("name="..player.name,minutes,seconds)
	end
end

--teleports a list of players to an exact place and sends them a message about it
local function teleportToPoint(x,y,z,playerlist,clear,textEN, textDE)
	for i,player in ipairs(playerlist) do
		player.x = x
		player.y = y
		player.z = z
		commands.async.gamemode(2,player.name)
		if clear then
			commands.async.clear(player.name,"wool")
			commands.async.clear(player.name,"stone_pickaxe")
		end
		commands.tp("@a[name="..player.name.."]",x,y,z)
		commands.async.tellraw(player.name,'["",{"text":"'..textEN..'","color":"white"}]')
		commands.async.tellraw(player.name,'["",{"text":"'..textDE..'","color":"gold"}]')
	end
end

--teleports a list of players to a given buildzone
local function teleportToZone(buildzone,playerlist,textEN, textDE)
	teleportToPoint(buildzone.x+2+(buildzone.w/2),buildzone.y+5,buildzone.z+2+(buildzone.w/2),playerlist,true,textEN, textDE)

end

--gives the same list of items to a list of players
local function giveItems(playerlist,itemlist)
	local given = 0
	for i,player in ipairs(playerlist) do
		--commands.async.clear(player.name)
		for j,item in ipairs(itemlist) do
			commands.async.give("@a[name="..player.name.."]",item)
			given = given +1
		end
		giveHomecomer(player.name)
	end
	return given
end

--a multi builder which uses the vocab constructor to create sets of vocab
local function makeVocabZones(quant,w)
	local x,y,z = FIRSTVOCAB.x, FIRSTVOCAB.y, FIRSTVOCAB.z
	local result = {}
	local id = 1
	for i=0,quant-1 do
		for k=0,3 do
			local zpos = i-4
			local ypos = k
			--print("vocab at X")
			--print(x-(2*w)-6)
			--print("and Z")
			--print(z+((w+1)*zpos))
			local nextVocab = newVocabZone(
				x-(2*w)-6,y+(ypos*(VOCAB_HEIGHT+3)),
				z+((w+1)*zpos),
				w,
				id,
				REWARDS[id] or DEFAULT_REWARD,
				VOCABS_DATA[id].nameEN or DEFAULT_NAME,
				VOCABS_DATA[id].nameDE or DEFAULT_NAME,
				VOCABS_DATA[id].typeEN,
				VOCABS_DATA[id].typeDE,
				VOCABS_DATA[id].height,
				VOCABS_DATA[id].slots,
				VOCABS_DATA[id].green,
				VOCABS_DATA[id].greenSlots,
				VOCABS_DATA[id].rewardUrban,
				VOCABS_DATA[id].rewardCount
			)
			table.insert(result,nextVocab)
			id = id +1
		end
	end
	return result
end

--finds the next free location(or buildzone) for a new game in a given area.
--giving force as True will mean it overrides the first location no matter what
local function findNextLoc(width,zones,force)
	local x,y,z,locid = 0,0,0,1
	for i,loc in ipairs(LOCS) do
		locid = i
		x,y,z = FIRSTZONE.x+(loc.x*(width+1)),FIRSTZONE.y,FIRSTZONE.z+(-loc.z*(width+1)) -- these are the coordinates of this LOC in the minecraft world
		--print("testing for available zone at: "..x..", "..y..", "..z)
		--print("which is at grid cell at: "..loc.x..", "..loc.z)
		--local result,message = commands.testforblock(x,y+BUILDZONE_FLOOR_HEIGHT,z,"minecraft:air") -- this was used for the testing based on the minecraft model
		local result = true
		if loc.played then
			result = false
			print("zone has been played")
		end
		--print("testing done")
		--force the first zone to be selected unless it is taken in the "zones" parameter
		if force then result = true end
		--checks if the zone is already in the list of unavailable zones passed as parameter
		local zonefree = true
		for i,zone in ipairs(zones) do
			if zone.x == x and zone.z == z then
				zonefree = false
			end
		end
		--print("next position free is ",loc.x*width,oy,loc.z*width)
		--if result then print("true") else print("false") end
		if result and zonefree then
			--print("using loc: ",loc.x,loc.z)
			return x,y,z,locid --returns the coordinates of the new zone, plus its id in the LOCS table
		end
	end
	return nil,nil,nil, nil --returns empty if no zone is available

end

--relocates a buildzone to a new coordinate safely
--avoids overlapping with other buildzones
function moveBuildzone(buildzone,zones)
	local x,y,z,locid = findNextLoc(buildzone.w,zones)
	if x and y and z and locid then
		print("moved buildzone from "..buildzone.x..","..buildzone.z.." to "..x..","..y)
		local w = buildzone.w
		buildzone.x,buildzone.y,buildzone.z = x,y+BUILDZONE_FLOOR_HEIGHT,z
		buildzone.locid = locid --reassign the location id corresponding to the LOCS item for the grid cell of the moved zone
		buildzone.selector = "x="..x..",y="..tostring(y-1)..",z="..z..",dx="..w..",dy=256,dz="..w
		buildzone.structures = {} --a list of all vocabularies which have been contructed
	else
		print("buildzone at "..buildzone.x..","..buildzone.z.." stayed where it is")
	end
end

--multi builder to create sets of buildzones using the buildzone constructor
local function makeBuildzones(quant,vocab,width,floorHeight)
	local result = {}
	for i=1,quant do
		--print("locating available slot")
		local x,y,z,locid = findNextLoc(width,result)
		if x and y and z and locid then
			--print("made new buildzone at",x,y,z)
			table.insert(result,newBuildZone(x,y+floorHeight,z,width,vocab,locid))
		else
			--print("failed to make new buildzone")
		end
	end

	local remaining = NUMBER_OF_BUILDZONES - #result
	--print("doing this remaining thing")
	for i=1, remaining do
		local x,y,z,locid = findNextLoc(width,result,true)
		if x and y and z and locid then
			--print("forced new buildzone at",x,y,z)
			table.insert(result,newBuildZone(x,y+floorHeight,z,width,vocab, locid))
		else
			print("failed to force new buildzone")
		end
	end


	return result
end

--vocab constructor. Enforces some data structure
function newVocabZone(x,y,z,w,id, reward,nameEN, nameDE, typeEN, typeDE, height, slots,green,greenSlots, rewardUrban, rewardCount)
	local nvz = {}
	nvz.x ,nvz.y ,nvz.z ,nvz.w = x,y,z,w

	nvz.cx = nvz.x - nvz.w - 2
	nvz.cy = nvz.y
	nvz.cz = nvz.z
	nvz.nameEN = nameEN
	nvz.reward = reward
	--- new stuff
	nvz.id = id
	nvz.nameDE = nameDE
	nvz.typeEN = typeEN
	nvz.typeDE = typeDE
	nvz.height = height
	nvz.slots = slots
	nvz.green = green
	nvz.greenSlots = greenSlots
	nvz.rewardUrban = rewardUrban
	nvz.rewardCount = rewardCount

	return nvz

end

--buildzone constructor. Enforces some data structure
function newBuildZone(x,y,z,w,vocabZones,locid)
	local nbz = {}
	nbz.x ,nbz.y ,nbz.z ,nbz.w = x,y,z,w
	nbz.selector = "x="..x..",y="..(y-5)..",z="..z..",dx="..w..",dy=256,dz="..w
	nbz.structures = {} --a list of all vocabularies names which have been contructed
	nbz.buildings = {} --a list of all vocabularies with full data (x,y,z,id,name) which have been contructed
	nbz.filledSlots = 0 --to count how many slots have been filled with buildings. the matrix is 7x7x20 slots. one slot is 9x9x9 blocks big
	nbz.greenSlots = 0 --to count how many of the slots are green. the matrix is 7x7x20 slots. one slot is 9x9x9 blocks big
	nbz.variety = {} -- this stores how many buildings of each type are there. it is indexed on vocab.id and the value is the number of buildings from type vocab.id
	nbz.waitingForCheck = {}
	nbz.highest = 0
	nbz.vocab = vocabZones
	nbz.locid = locid

	return nbz
end

--kew constructor. Enforces some data structure
function newQueue(buildzone,maxplayers)
	local q = {}
	q.timer = 1
	q.phase = 1

	q.victory = false
	q.phases = {
		{
		name = "Selecting Players",
		length = PHASE_LENGTH_WAIT,
		displaylength = 15 --this field is not used
		},
		{
		name = "Game In Progress",
		length = PHASE_LENGTH_GAME,
		displaylength = 70 --this field is not used
		},
		{
		name = "Round Complete",
		length = PHASE_LENGTH_OVER,
		displaylength = 5 --this field is not used
		}
	}
	q.playerlist = {}
	q.maxplayers = maxplayers
	q.buildzone = buildzone

	return q
end


--creates a ring of blocks using coordinates
function fillRing(x,y,z,w,block)
	commands.fill(x,y,z,x+w,y,z,block)
	commands.fill(x+w,y,z,x+w,y,z+w,block)
	commands.fill(x,y,z+w,x+w,y,z+w,block)
	commands.fill(x,y,z+w,x,y,z,block)
end

function setup()
	print("debug: starting setup function.")
	local game = {}
	game.vocab = {}
	game.builds = {}
	game.queues = {}
	game.waitlist = {}
	game.spawn = SPAWN
	game.lastClock = os.clock()
	game.nowTime = os.clock()

	--generate vocab rewards
	for i=1,#VOCABS_DATA do
		if VOCABS_DATA[i].rewardUrban then
			REWARDS[i] = houseBlock(VOCABS_DATA[i].rewardCount)
		else
			REWARDS[i] = gardenBlock(VOCABS_DATA[i].rewardCount)
		end
	end

	--kill all villagers
	commands.exec("kill @e[type=Villager]")

	--buildzone and vocabzone creation
	print("debug-setup: making vocab zones.")
	game.vocab = makeVocabZones(NUMBER_OF_VOCAB,VOCAB_WIDTH)
	print("debug-setup: making building zones.")
	--game.builds appears to store the games currently in progress
	game.builds = makeBuildzones(NUMBER_OF_BUILDZONES,game.vocab,BUILDZONE_WIDTH,BUILDZONE_FLOOR_HEIGHT)

	for i,build in ipairs(game.builds) do
		table.insert(game.queues,newQueue(build, MAX_PLAYERS_PER_GAME))
	end
	print("debug-setup: testing for properly setup vocabs.")
	for i,vz in ipairs(game.vocab) do
		local x,y,z,w = vz.x,vz.y,vz.z,vz.w
		local cx,cy,cz = vz.cx,vz.cy,vz.cz

		local detector, message1 = commands.testforblock(x+(math.floor(w/2)),y,z+(math.floor(w/2)),BLOCKS.DETECT.block)
		local blocker, message2 = commands.testforblock(x+(math.floor(w/2)),y,z+(math.floor(w/2)),BLOCKS.DETECT_DEAD.block)
		if not (detector or blocker) then
			for nx=0,2 do
				for nz=0,2 do
					commands.setblock(x+(nx*9)+4,y-1,z+(nz*9)+4,BLOCKS.VOCAB_REPLACE.block)
					commands.setblock(cx+(nx*9)+4,cy-1,cz+(nz*9)+4,BLOCKS.VOCAB_DETECT.block)
				end
			end
			commands.setblock(x+(math.floor(w/2)),y,z+(math.floor(w/2)),BLOCKS.DETECT_DEAD.block)

		end

	end

	print("debug-setup: adding scoreboards.")

	--print(#VOCABS_DATA)
	for i=1,#VOCABS_DATA do
		commands.scoreboard("objectives","add","building_"..i,"dummy")
	end

	--commands.gamerule("doDaylightCycle",false) -- this is included in the spawn controller script
	commands.gamerule("keepInventory",true)
	--commands.gamerule("doTileDrops",false) -- this is included in the spawn controller script
	--commands.gamerule("logAdminCommands",false) -- this is included in the spawn controller script
	--commands.gamerule("commandBlockOutput",false) -- this is included in the spawn controller script
	--commands.time("set",6000) -- this is included in the spawn controller script
	commands.scoreboard("objectives","add","highscores","dummy","Best Neighbourhoods")
	commands.scoreboard("objectives","add","VillagerLife","dummy")
	commands.scoreboard("objectives","add","built","dummy", "Structures Built")
	commands.scoreboard("objectives","add","highest","dummy", "Personal Highest")
	commands.scoreboard("objectives","add","played","dummy","Games Played")

	commands.title("@a","times",0,30,30) -- what does this do?

	math.randomseed( os.time() )
	commands.scoreboard("objectives","setdisplay","sidebar","highscores")
	commands.scoreboard("objectives","setdisplay","list","played")

	--print("time is: "..os.time())
	--print( "time is: "..textutils.formatTime( os.time(), false ) )
	--print("day is: "..os.day())
	print("computer clock is: "..os.clock())

	if DEBUG_MODE then
		for i,build in ipairs(game.builds) do
			build.phase = 2
			build.timer = 500
		end
	end

	print("Computer Co-ordinates ",ox,oy,oz)
	print("20.000 Blocks Active!")

	return game
end

function checkForHomecomers(game)
	--execute on all homecomers
	local homecomers = getHomecomers()
	dealWithHomecomers(game,homecomers)
end

--main game loop
--runs the game object through each of these update steps in order
function update(game)
	local elapsed = updateClock(game)
	--update players
	checkPlayers(game)
	doTimerUpdates(game,elapsed)
	doPhaseUpdates(game)
	doPhaseEnds(game)
	checkBoundaries(game)
	checkForHomecomers(game)
	if #game.waitlist > 0 then allocateWaiters(game) end
end

--calculates elapsed time during a game tick
function updateClock(game)
	game.nowTime = os.clock()
	local elapsed = game.nowTime - game.lastClock
	game.lastClock = game.nowTime
	return elapsed
end

--updates all kews in the game object based on elapsed time
function doTimerUpdates(game,elapsed)
	for i,kew in ipairs(game.queues) do
		kew.timer = kew.timer - elapsed
	end
end

--check players are inside their buildzone and move them back if not
function checkBoundaries(game)
	for i,kew in ipairs(game.queues) do
		if kew.phase ==2 then
			--boundaries
			local x_min = kew.buildzone.x
			local x_max = kew.buildzone.x+kew.buildzone.w
			local z_min = kew.buildzone.z
			local z_max = kew.buildzone.z+kew.buildzone.w

			local toBeCorrected = {}

			for j,player in ipairs(kew.playerlist) do
				local listOfOne = getAllPos('m=2,name='..player.name)
				if listOfOne and listOfOne[1] then
					player.x = listOfOne[1].x
					player.y = listOfOne[1].y
					player.z = listOfOne[1].z
					local changed = false
					if player.x > x_max then
						changed = true
						player.x = x_max-2
					end
					if player.x < x_min then
						changed = true
						player.x = x_min+2
					end
					if player.z > z_max then
						changed = true
						player.z = z_max-2
					end
					if player.z < z_min then
						changed = true
						player.z = z_min+2
					end
					if changed then teleportToPoint(player.x,kew.buildzone.y,player.z,{player},false,"TELEPORTED BACK TO GAME: Please stay inside the building zone or use HOMECOMER to leave the game!", "Zurück ins Spiel teleportiert: Bitte bleib innerhalb des Baufeldes oder nutze den HEIMKEHRER um das Spiel zu verlassen!") end
				end
			end
		end
	end
end


--here you can set the logic which determines if a buildzone was valuable.
--Return true if it is crap and should be replaced
function checkIfBuildzoneIsCrap(buildzone)
	if #buildzone.structures < MIN_BUILDINGS then
		print("Buildzone was crap")
		return true
	end
	print("Buildzone was ok")
	return false
end


--Everything that happens after a buildzone was completed
--due to time limit.
function cleanAfterGameOver(kew)
	local buildzone = kew.buildzone
	commands.async.setblock(buildzone.x,buildzone.y,buildzone.z,BLOCKS.VICTORY_MARKER.block)
	fillRing(buildzone.x,buildzone.y,buildzone.z,buildzone.w,"minecraft:air",0,"replace",BLOCKS.CONSTRUCTION.block,BLOCKS.CONSTRUCTION.data)
	for h=0,256-buildzone.y do
		commands.async.fill(buildzone.x,buildzone.y+h,buildzone.z,buildzone.x+buildzone.w,buildzone.y+h,buildzone.z+buildzone.w,"minecraft:air 0","replace",BLOCKS.DETECT.block,BLOCKS.DETECT.data)
		commands.async.fill(buildzone.x,buildzone.y+h,buildzone.z,buildzone.x+buildzone.w,buildzone.y+h,buildzone.z+buildzone.w,"minecraft:air 0","replace",BLOCKS.PLUG.block,BLOCKS.PLUG.data)
		commands.async.fill(buildzone.x,buildzone.y+h,buildzone.z,buildzone.x+buildzone.w,buildzone.y+h,buildzone.z+buildzone.w,"minecraft:air 0","replace",BLOCKS.BUILDING_GARDEN.block,BLOCKS.BUILDING_GARDEN.data)
		commands.async.fill(buildzone.x,buildzone.y+h,buildzone.z,buildzone.x+buildzone.w,buildzone.y+h,buildzone.z+buildzone.w,"minecraft:air 0","replace",BLOCKS.BUILDING_HOUSE.block,BLOCKS.BUILDING_HOUSE.data)
	end
	commands.async.fill(buildzone.x,buildzone.y-1,buildzone.z,buildzone.x+buildzone.w,buildzone.y-1,buildzone.z+buildzone.w,BLOCKS.CAMP_FLOOR.block,BLOCKS.CAMP_FLOOR.data,"replace",BLOCKS.PLUG.block,BLOCKS.PLUG.data)
	commands.async.fill(buildzone.x,buildzone.y,buildzone.z,buildzone.x+buildzone.w,buildzone.y,buildzone.z+buildzone.w,BLOCKS.PHVFLOOR.block,BLOCKS.PHVFLOOR.data,"replace","minecraft:air","0")

	---add here a message to the players that they can see their finished game on the webviewer OR that their game was not save because they built too little

	local wasCrap = checkIfBuildzoneIsCrap(buildzone)
	local gameovermessageEN
	local gameovermessageDE
	if wasCrap then
		--mark this buildzone for replacement
		--change the flag to played=false
		updateZonePlayedState(buildzone,false)
		gameovermessageEN = "Thank you for playing IBA_GAME! This game will be discarded because you built less than "..MIN_BUILDINGS.." buildings. Play another game or check what others have built at: www.20000blocks.com"
		gameovermessageDE = "Vielen Dank, dass du IBA_GAME gespielt hast! Diese Runde wird verworfen, da weniger als "..MIN_BUILDINGS.." Gebäude gebaut wurden. Starte eine neue Runde oder schau dir die Spielergebnisse anderer Spieler an unter: www.2000blocks.com"

	else
		--change the flag to played=true
		updateZonePlayedState(buildzone,true)

		gameovermessageEN = "Thank you for playing IBA_GAME! Play another game or look for your game result at: www.20000blocks.com"
		gameovermessageDE = "Vielen Dank, dass du IBA_GAME gespielt hast! Starte eine neue Runde oder schau dir deine Spielergebnisse an unter: www.20000blocks.com"
	end

	for _, player in ipairs(kew.playerlist) do
		-- announce success in English
		commands.async.tellraw(player.name,'["",{"text":"'..gameovermessageEN..'","color":"white"}]')
		-- announce success in German
		commands.async.tellraw(player.name,'["",{"text":"'..gameovermessageDE..'","color":"gold"}]')
	end

end

function updateZonePlayedState(buildzone, newstate)
	--change the flag to played=newstate
	LOCS[buildzone.locid].played = newstate
	--and write the LOCS object to the json file
	writeGridToFile()
end

--these happen every tick and require the game object
--updates are performed on each Queue (kew) and within each
--of those on each buildzone.
function doPhaseUpdates(game)
	for i,kew in ipairs(game.queues) do

		local minutes = string.format("%02d",math.floor(kew.timer/60))
		local seconds = string.format("%02d",math.floor(kew.timer - (minutes*60)))
		if kew.timer <= 0 then
			minutes = "00"
			seconds = "00"
		end

		if kew.phase == 1 then
			--waiting phase
			if #kew.playerlist == kew.maxplayers and kew.timer > 5 then kew.timer = 5 end
			if not DEBUG_MODE and #kew.playerlist == 0 then kew.timer = kew.phases[1].length end

			displayTitleToGroup(kew.playerlist,"Game starting!")
			displayTimeToGroup(kew.playerlist,minutes,seconds)
			--show countdown
		elseif kew.phase == 2 then
			--playing phase
			if #kew.playerlist == 0 then timer = 0 end -- finish if all players quit
			-- do vocab logic
			local victory = updatePlayedZone(kew.buildzone) --currently victory updatePlayedZone returns always false
			--
			displayTimeToGroup(kew.playerlist,minutes,seconds)

		elseif kew.phase == 3 then
			--end phase
			displayTitleToGroup(kew.playerlist,"Use HOMECOMER to return")
			--displayTimeToGroup(kew.playerlist,minutes,seconds)


		end
	end
end

--this runs after a buildzone is completed
--it should tally structure types and set scoreboard highscores
--it also rewards all participants with more played score
function processHighscores(kew)
	local buildzone = kew.buildzone



	--add score to players who finished this game
	for _,player in ipairs(kew.playerlist) do
		commands.async.scoreboard("players","add",player.name,"played",1)
	end
end

--function to export a buildzone detail once it is complete
--requires a kew so it can access the playerlist
local function exportKewData(kew)
	local buildzone = kew.buildzone
	local saved = {}
	saved.position =
		{
			x=buildzone.x,
			y=buildzone.y,
			z=buildzone.z
		}
	local timestamp = math.floor(os.clock())
	--saved.timeCompleted = timestamp
	saved.players = {}
	for _, player in ipairs(kew.playerlist) do
		table.insert(saved.players,player.name)
	end
	--saved.structures = buildzone.structures
	saved.buildings = buildzone.buildings
	saved.totals = tracker.tallyTable(buildzone.structures)
	--saved.highest = buildzone.highest
	saved.stats = {
		cityVersion = CITY_VERSION,
		height = buildzone.highest,
		densityIndex = math.floor(100*buildzone.filledSlots/49), -- the density index is made from built area (filledSlots) over the ground area (7x7 slots = 49)
		greenIndex = math.floor(100*buildzone.greenSlots/49), --the green index is made from green area (greenSlots) over the ground area (7x7 slots = 49)
		variety = tablelength(buildzone.variety),
		timeCompleted = timestamp,
		gameLength = PHASE_LENGTH_GAME
	}

	fs.makeDir("/records")

	filename = timestamp.."at"..buildzone.x.."_"..buildzone.z
	local file = fs.open("/records/"..filename..".yaml","w")

	filecontent = json.encodePretty(saved)
	file.write(filecontent)


	local test = http.get("http://www.20000blocks.com/DatabaseAccess/GetVersion.php")
	if test then
		print("test is valid:"..test)
	else
		print("test is nil")
	end


	local link = http.post(
		"http://www.20000blocks.com/DatabaseAccess/UploadModel.php",
		"name="..textutils.urlEncode(filename).."&"..
		"content="..textutils.urlEncode(filecontent).."&"..
		"x="..buildzone.x.."&"..
		"z="..buildzone.z
	)


	if 0 == 1 then --this currently doesnt work because the link variable is all the time nil

	print(link.getResponseCode())
	if link.readAll() then
		local linkmsgEN = 'The latest game result has been uploaded to the webviewer and can be seen at:'..link.readAll()
		local linkmsgDE = 'Die neueste Runde wurde in den Webviewer geladen und kann hier angeschaut werden:'..link.readAll()
		-- announce success in English
		commands.async.tellraw("@a",'["",{"text":"'..linkmsgEN..'","color":"white"}]')
		--announce success in German
		commands.async.tellraw("@a",'["",{"text":"'..linkmsgDE..'","color":"gold"}]')
	end
	end

	file.close()
end

function switchVersion(id, relative) --id is the new version, relative is whether it is incrmenting the last version (true means the number in id will be added to the current version, false is id is the new version number)
	http.post(
		"http://www.20000blocks.com/DatabaseAccess/SwitchVersion.php",
		"id="..textutils.urlEncode(id).."&"..
		"relative="..textutils.urlEncode(relative)
	)
end

--this code runs ONCE at the end of each phase
--what actually happens is specific to which phase the
--particular kew is in.
function doPhaseEnds(game)
	for i,kew in ipairs(game.queues) do
		if kew.timer <= 0 then
			if kew.phase == 1 then
				--waiting phase ends goto play phase

				moveBuildzone(kew.buildzone,game.builds) --what does this do?
				teleportToZone(kew.buildzone,kew.playerlist,"Your game has started! BUILD A HOUSE!", "Das Spiel hat begonnen! BAUE EIN HAUS!")--teleport selected players
				cleanBuildzone(kew.buildzone)
				prepareBuildzone(kew.buildzone)--prepare build zone
				giveItems(kew.playerlist,STARTING_ITEMS) --give starting items
				displayTitle(kew.buildzone.selector,"BUILD!")
				kew.victory = false
				--displayTime(kew.buildzone.selector,0,0)
				kew.phase = 2
				kew.timer = kew.phases[kew.phase].length
			elseif kew.phase == 2 then
				--playing phase ends goto end phase
				processHighscores(kew)
				exportKewData(kew)
				cleanAfterGameOver(kew)
				kew.phase = 3
				--displayTime(kew.buildzone.selector,0,0)
				kew.timer = kew.phases[kew.phase].length
			elseif kew.phase == 3 then
				--end phase ends goto waiting phase
				removePlayersFromKew(game,kew)
				kew.phase = 1
				--displayTime(kew.buildzone.selector,0,0)
				kew.timer = kew.phases[kew.phase].length
			end
		end
	end
end


--Replaces everything that is needed to start the game. Does not rebuild the floor, or clear anything away.
--based on the settings it creates a full grid, or a partial grid, or no grid
--it also places the ring, although this is disabled for now
function prepareBuildzone(buildzone)
	local bz = buildzone
	local x,y,z,w = bz.x,bz.y,bz.z,bz.w

	commands.async.fill(x,y-1,z,x+w,y-1,z+w,BLOCKS.CAMP_FLOOR.block) --place the white grid accross the full buildzone as a base

	fillRing(buildzone.x,buildzone.y-1,buildzone.z,buildzone.w,BLOCKS.CONSTRUCTION.block) --this draws the construction stripe around the buildzone
	--create the grid of detectors surrounded by plus plugs
	if DO_GRID then
		for x=0,GRIDCELL_COUNT-1 do
			for z=0,GRIDCELL_COUNT-1 do
				local rand = math.random()*100
				--local result, text = commands.testforblock(bz.x+(x*9)+4,bz.y-1,bz.z+(z*9)+4,BLOCKS.CAMP_FLOOR.block)
				if rand > GRID_HOLE_CHANCE then --and result then
					local halfCell = math.floor(GRIDCELL_SIZE/2)
					commands.async.setblock(bz.x+(x*GRIDCELL_SIZE)+halfCell,bz.y,bz.z+(z*GRIDCELL_SIZE)+halfCell,BLOCKS.DETECT.block,BLOCKS.DETECT.data,"replace","minecraft:air")
					commands.async.fill(bz.x+(x*GRIDCELL_SIZE)+halfCell-PLUG_LENGTH, bz.y-1,bz.z+(z*GRIDCELL_SIZE)+halfCell,bz.x+(x*GRIDCELL_SIZE)+halfCell+PLUG_LENGTH,bz.y-1,bz.z+(z*GRIDCELL_SIZE)+halfCell,BLOCKS.PLUG.block)
					commands.async.fill(bz.x+(x*GRIDCELL_SIZE)+halfCell,bz.y-1,bz.z+(z*GRIDCELL_SIZE)+halfCell-PLUG_LENGTH,bz.x+(x*GRIDCELL_SIZE)+halfCell,bz.y-1,bz.z+(z*GRIDCELL_SIZE)+halfCell+PLUG_LENGTH,BLOCKS.PLUG.block)
				end
			end
		end
	end
	--mark the game in the LOCS array as not available anymore, and save the updated game grid to the grid file
	--change the flag to played=true
	updateZonePlayedState(buildzone,true)
end

--deletes everything inside the buildzone
function cleanBuildzone(buildzone)
	print("Cleaning buildzone")
	for h=buildzone.y,255 do
		commands.async.fill(buildzone.x,h,buildzone.z,buildzone.x+buildzone.w,h,buildzone.z+buildzone.w,"minecraft:air")
	end
end

function removePlayersFromKew(game,kew)
	for _, player in ipairs(kew.playerlist) do
		--commands.tell(player.name,"Your game is over. Use your Heimkehrer to return to spawn")
		-- announce success in English
		commands.async.tellraw(player.name,'["",{"text":"TIME OUT! GAME COMPLETE! Use your HOMECOMER to return to spawn.","color":"white"}]')
		-- announce success in German
		commands.async.tellraw(player.name,'["",{"text":"ENDE! SPIEL ABGESCHLOSSEN! Nutze den HEIMKEHRER um zum Anfang zurück zu kehren.","color":"gold"}]')
	end
	kew.playerlist = {}
end

function respawnPlayer(playername,message)
	commands.tell(playername,message)
	commands.async.gamemode(2,playername)
	commands.async.clear(playername,"minecraft:wool")
	commands.async.clear(playername,"minecraft:stone_pickaxe")
end

function checkForPlayerInBuildzone(player,buildzone)
	local result,message = commands.testfor('@a[name='..player.name..','..buildzone.selector..']')
	return result
end

function checkForPlayerInWaitzone(player)
	local selector = "x="..WAITZONE.x..",y="..WAITZONE.y..",z="..WAITZONE.z..",dx="..WAITZONE.w..",dy=256,dz="..WAITZONE.l
	local result,message = commands.testfor('@a[name='..player.name..','..selector..']')
	return result
end

function checkPlayers(game)
	local selector = "x="..WAITZONE.x..",y="..WAITZONE.y..",z="..WAITZONE.z..",dx="..WAITZONE.w..",dy=256,dz="..WAITZONE.l
	local loggedIn = getAllPos('m=2,'..selector)
	--refresh waitlist
	game.waitlist = loggedIn
	--check currently playing players
	for l,kew in ipairs(game.queues) do
		for i,builder in ipairs(kew.playerlist) do
			local isPlaying = checkForPlayerInBuildzone(builder,kew.buildzone)
			--remove players who are already in kews from the waitlist
			for j, player in ipairs(loggedIn) do
				if player.name == builder.name then
					table.remove(loggedIn,j)
				end
			end
			--if the game is in progress and the player is not found then remove them from the gamekew
			if not isPlaying and kew.phase == 2 then
				--table.remove(kew.playerlist,i)
				--print("Removed "..builder.name.." from game in progress")
			end
		end
	end
end

--adds players who wait in the orange room to slots in waiting buildzones
function allocateWaiters(game)
	--find free slots
	local freeslots = {}
	for i, kew in ipairs(game.queues) do
		if kew.phase == 1 and #kew.playerlist < kew.maxplayers then
			local slots = kew.maxplayers - #kew.playerlist
			for j=1,slots do
				table.insert(freeslots,kew)
			end
		end
	end

	--RE-ENABLE SECOND SHUFFLETABLE IF YOU WANT RANDOM PLAYER MATCHUPS
	shuffleTable(game.waitlist)
	--shuffleTable(freeslots)

	while #freeslots > 0 and #game.waitlist > 0 do
		local player = table.remove(game.waitlist,1)
		local freeslot = table.remove(freeslots,1).playerlist
		table.insert(freeslot,player)
	end
end

--PARTICLE FUNCTIONS
--particles shown to player while their shape is being checked for match
function searchParticle(x,y,z)
	commands.async.particle("fireworksSpark",x,y,z,0.01,3,0.01,0.01,100)
end
-- particles shown to player on successful vocab match
function successParticle(x,y,z)
	commands.async.particle("happyVillager",x,y,z,2,2,2,1,1000)
	commands.async.playsound("random.levelup","@a",x,y,z,1,1.2)
end
--- particles shown to player on failed vocab match
function failParticle(x,y,z)
	commands.async.particle("reddust",x,y,z,0.1,0.1,1.5,1,200)
	commands.async.particle("reddust",x,y,z,1.5,0.1,0.1,1,200)
	commands.async.playsound("random.bowhit","@a",x,y,z,1,0.8)
end

--makes sure that incoming check requests dont exist already
function addToChecklist(player,buildzone)
	for _, detector in ipairs(buildzone.waitingForCheck) do
		if detector.x == player.x and detector.y == player.y and detector.z == player.z then
			return false
		end
	end
	table.insert(buildzone.waitingForCheck,player)
	return true
end

--removes all barrier blocks from a buildzone which are used to carve space in vocabs
function cleanBarriers(buildzone)
	for h=0,200 do
		commands.async.fill(buildzone.x,buildzone.y+h,buildzone.z,buildzone.x+buildzone.w,buildzone.y+h,buildzone.z+buildzone.w,"minecraft:air",0,"replace","minecraft:barrier")
	end
end

--The main chunk of code which deals with stepping on detector blocks and reading the vocab
function updatePlayedZone(buildzone)
	local victory = false
	local buildzoneSelector = buildzone.selector
	--get all players on a detector block, add them to the list of things to check
	local detectLocations = getAllOnBlockType(BLOCKS.DETECT.block,buildzoneSelector)
	for _, player in ipairs(detectLocations) do
		addToChecklist(player,buildzone)
	end

	--DEAL WITH THE DETECTOR AT THE TOP OF THE LIST IF THERE IS ONE
	if #buildzone.waitingForCheck > 0 then
		--DO PARTICLE EFFECTS IF A DETECTING BLOCK THAT IS DETECTING
		for i,loc in ipairs(buildzone.waitingForCheck) do
			searchParticle(loc.x,loc.y+1,loc.z)
		end
		local totalResult = false
		local checked = table.remove(buildzone.waitingForCheck,1)
		local x,y,z,name = checked.x,checked.y,checked.z,checked.name
		for i,vocab in pairs(buildzone.vocab) do
			local result,message = commands.testforblocks( vocab.x, vocab.y, vocab.z, vocab.x+vocab.w, vocab.y+VOCAB_HEIGHT, vocab.z+vocab.w, x-math.floor(vocab.w/2), y-1, z-math.floor(vocab.w/2),"masked")
			if result then
				--clone in the correct vocab
				local cloneres,clonemes = commands.clone( vocab.cx, vocab.cy, vocab.cz, vocab.cx+vocab.w, vocab.cy+VOCAB_HEIGHT, vocab.cz+vocab.w, x-math.floor(vocab.w/2), y-1, z-math.floor(vocab.w/2),"masked")
				if DEBUG_MODE then
					print(clonemes[1])
				end
				commands.async.give(name,vocab.reward)
				-- announce vocab success in English
				local rewardType = 'nature'
				local rewardTypeDE = 'grüne'
				if vocab.rewardUrban then
					rewardType = 'urban'
					rewardTypeDE = 'urbane'
				end
				--print(vocab.typeEN)
				--print(vocab.nameEN)
				--print(vocab.height)
				--print(vocab.slots)
				--print(vocab.greenSlots)
				--print(vocab.rewardCount)
				--print(rewardType)
				commands.async.tellraw(name,'["",{"text":"You built a '..vocab.nameEN.. ' ('..vocab.typeEN..'), which is '..vocab.height..'m tall and gives '..vocab.slots..' density pts, '..vocab.greenSlots..' green pts and '..vocab.rewardCount..'x '..rewardType..' resource!","color":"white"}]')
				-- announce vocab success in German
				commands.async.tellraw(name,'["",{"text":"Du hast ein '..vocab.typeDE..' | '..vocab.nameDE.. ' gebaut, das '..vocab.height..' Meter hoch ist und dir '..vocab.slots..' Punkte für die Dichte einbringt, jedoch '..vocab.greenSlots..' Punkte für Grünflächen und '..vocab.rewardCount..' '..rewardTypeDE..' Ressourcen!","color":"gold"}]')
				--clear out barrier blocks
				cleanBarriers(buildzone)

				--ADD THE NEW STRUCTURE TO THE RECORDS
				table.insert(buildzone.structures,vocab.nameEN)
				--record the place of the vocab as x, y, z and vocab id
				local building = {id=vocab.id,xpos=x,ypos=y,zpos=z,name=vocab.nameEN,time=os.clock(),player=name}
				table.insert(buildzone.buildings, building)
				--if vocab.green then
				buildzone.greenSlots = buildzone.greenSlots + vocab.greenSlots
				--end
				buildzone.filledSlots = buildzone.filledSlots + vocab.slots
				local newHeight = y + vocab.height - buildzone.y-1 -- the Y coordinate of the highest block above the ground. Our world has its ground at 55 which is in buildzone.y, subtracting 1 to compensate for player height
				if newHeight > buildzone.highest then
					buildzone.highest = newHeight
				end
				-- count variety
				--print("adding variety: "..vocab.id)
				local varietyId = vocab.id -- we use a variety id instead of the vocab id because vocab id 1,2,3,4 for example are all houses so it is the same variety
				--we add only one type of house, one type of green house, one type of garden and one type of extension and we skip the two risers
				if vocab.id == 2 or vocab.id == 3 or vocab.id == 4 then varietyId = 1 end-- only one type for the 4 different orientations of the house
				if vocab.id == 14 or vocab.id == 15 or vocab.id == 16 then varietyId = 13 end-- only one type for the 4 different orientations of the house extension
				if vocab.id == 26 or vocab.id == 27 or vocab.id == 28 then varietyId = 25 end-- only one type for the 4 different orientations of the house garden extension
				if vocab.id == 38 or vocab.id == 39 or vocab.id == 40 then varietyId = 37 end-- only one type for the 4 different orientations of the green roof house
				if varietyId ~= 17 and varietyId ~= 18 then --skip the two riser as they ar enot buildings
					if buildzone.variety[varietyId] then
						--print("increasing existing item")
						buildzone.variety[varietyId] = buildzone.variety[varietyId] + 1
					else
						--print("adding new item")
						buildzone.variety[varietyId] = 1
					end
				end

				--- CHECK FOR PERSONAL RECORDS
				--- check if the new structure is the highest
				--- CHANGE here to live detect the contribution of the new structure to the 4 goals and update them

				local personalbest = tracker.getScore(name,"highest")
				if personalbest.count < newHeight then
					--commands.async.tell(name,"You just topped your personal record for highest structure!")
					commands.async.scoreboard("players","add",name,"highest",1)
					-- announce success in English
					commands.async.tellraw(name,'["",{"text":"You just topped your personal record for highest neighbourhood!","color":"green"}]')
					-- announce success in German
					commands.async.tellraw(name,'["",{"text":"Du hast soeben deinen persönlichen Rekord für die höchste Nachbarschaft gebrochen!","color":"gold"}]')
				end

				---
				---
				-- CHECK if placing the current structure would result in beating a server-wide record on the 4 goals
				--calculate total slots - FOR GOAL "DENSEST NEIGHBOURHOOD"
				local most = tracker.getScore("Densest_[points]","highscores")
				local Kint = math.floor(100 * buildzone.filledSlots / 49) -- Kint is the density index made from built area (filledSlots) over ground area (7x7 slots = 49)
				if Kint > most.count then
					commands.async.scoreboard("players","set","Densest_[points]","highscores",Kint)
					-- announce success in English
					commands.async.tellraw("@a",'["",{"text":"Great! '..name.. ' just topped the record for the DENSEST NEIGHBOURHOOD!","color":"green"}]')
					-- announce success in German
					commands.async.tellraw("@a",'["",{"text":"Sehr gut! '..name.. ' hat einen neuen Rekord für die DICHTESTE NACHBARSCHAFT aufgestellt!","color":"gold"}]')
					--commands.async.say("@a","The record for the Densest Neighbourhood has been topped!")
				end

				-- FOR THE GOAL "MOST DIVERSE NEIGHBOURHOOD"
				-- here we need to count how many varieties of buildings there are
				--local structures = tracker.tallyTable(buildzone.structures) -- this counts the variety of buildings in a game
				local mostDiverse = tracker.getScore("Most-Diverse_[out-of-26]","highscores")
				local typeCount = tablelength(buildzone.variety)
				--print("variety count is: "..typeCount)
				if typeCount > mostDiverse.count then
					commands.async.scoreboard("players","set","Most-Diverse_[out-of-26]","highscores", typeCount)
					-- announce success in English
					commands.async.tellraw("@a",'["",{"text":"Wow! '..name.. ' just topped the record for the MOST DIVERSE NEIGHBOURHOOD!","color":"green"}]')
					-- announce success in German
					commands.async.tellraw("@a",'["",{"text":"Wow! '..name.. ' hat soeben einen neuen Rekord für die VIELSEITIGSTE NACHBARSCHAFT aufgestellt!","color":"gold"}]')
					--commands.async.say("@a","The record for the Most Diverse Neighbourhood has been topped!")
				end

				-- FOR THE GOAL "GREENEST NEIGHBOURHOOD"
				-- here we need to count the number of green vocabs
				local greenest = tracker.getScore("Greenest_[points]","highscores")
				local Gint = math.floor(100*buildzone.greenSlots/49) --Gint is the green index, made from green area (greenSlots) over ground area (7x7 slots = 49)
				if Gint > greenest.count then
					commands.async.scoreboard("players","set","Greenest_[points]","highscores",Gint)
					-- announce success in English
					commands.async.tellraw("@a",'["",{"text":"Awesome! '..name.. ' just topped the record for the GREENEST NEIGHBOURHOOD!","color":"green"}]')
					-- announce success in German
					commands.async.tellraw("@a",'["",{"text":"Klasse! '..name.. ' hat einen neuen Rekord für die GRÜNSTE NACHBARSCHAFT aufgestellt!","color":"gold"}]')
					---commands.async.say("@a","The record for the Densest Neighbourhood has been topped!")
				end

				--calculate highest placement -- FOR THE GOAL "TALLEST NEIGHBOURHOOD"
				local highest = tracker.getScore("Tallest_[meters]","highscores")
				if buildzone.highest > highest.count then
					commands.async.scoreboard("players","set","Tallest_[meters]","highscores",buildzone.highest)
					-- announce success in English
					commands.async.tellraw("@a",'["",{"text":"Incredible! '..name..' just topped the record for TALLEST NEIGHBOURHOOD!","color":"green"}]')
					-- announce success in German
					commands.async.tellraw("@a",'["",{"text":"Unglaublich! '..name..' hat einen neuen Rekord für die HÖCHSTE NACHBARSCHAFT aufgestellt!","color":"gold"}]')
					--commands.async.say("@a","The record for the Tallest Negihbourhood has been topped!")
				end


				--increase the "how many structures did i build" score for the building player
				commands.async.scoreboard("players","add",name,"built",1)
				commands.async.scoreboard("players","add",name,"building_"..vocab.id,1)

				totalResult = true
				break

			end
		end
		if totalResult then
			--yey win, do a happy time
			successParticle(x,y,z)
		else
			--no vocab found so do a fail particle
			--announce in English
			commands.async.tellraw(name,'["",{"text":"The shape you have built does not match any shape in the catalogue, try a different one.","color":"red"}]')
			-- announce in German
			commands.async.tellraw(name,'["",{"text":"Die Kombination, die du gebaut hast passt leider zu keinem Gebäude, versuche es mit einer anderen Form.","color":"gold"}]')
			failParticle(x,y-1,z)
		end
	end
	return victory
end

-- returns how many items are in a table/list
function tablelength(T)
  local count = 0
  for _ in pairs(T) do count = count + 1 end
  return count
end

--Display game information on the monitor
function debugDisplay(game)
	monitor.clear()
 if blink then
  monitor.setCursorPos(1,1)
  monitor.setTextColor(colors.red)
  monitor.write("Running")
  monitor.setTextColor(colors.white)
  redstone.setOutput("top",true)
  blink = false
 else
  redstone.setOutput("top",false)
  blink = true
 end
	local line = 2

	for i,kew in ipairs(game.queues) do
		monitor.setCursorPos(1,line)
		local minutes = string.format("%02d",math.floor(kew.timer/60))
		local seconds = string.format("%02d",math.floor(kew.timer - (minutes*60)))
		monitor.write("Buildzone "..i.." |  Phase: "..kew.phase.." |  Time: "..minutes..":"..seconds)
		monitor.setCursorPos(1,line+1)
		for i,player in ipairs(kew.playerlist) do
			monitor.write(player.name.." ")
		end
		line = line +2
	end

	monitor.setCursorPos(1,10)
	for i,player in ipairs(game.waitlist) do
		monitor.write(player.name.." ")
	end
end

--BEGIN RUNTIME CODE
local blink = true
local game = setup()
while true do
	update(game)
	if monitor then debugDisplay(game) end
	commands.async.weather("clear",10000)

	local resetbutton = redstone.getInput("left")
	if resetbutton then
		print("reset!")
		for i,kew in ipairs(game.queues) do
			if kew.phase == 2 then
				kew.timer = 5
			end
		end
	end
	sleep(2)
end