unit_terraform.lua

-- $Id: unit_terraform.lua 4610 2009-05-12 13:03:32Z google frog $
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

function gadget:GetInfo()
  return {
    name      = "Terraformers",
    desc      = "Terraforming script for lasso based area/line terraform, also ramp",
    author    = "Google Frog",
    date      = "Nov, 2009",
    license   = "GNU GPL, v2 or later",
    layer     = 0,
    enabled   = true  --  loaded by default?
  }
end

-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
if gadgetHandler:IsSyncedCode() then

--------------------------------------------------------------------------------
-- SYNCED
--------------------------------------------------------------------------------

-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
local USE_TERRAIN_TEXTURE_CHANGE = true -- (Spring.GetModOptions() or {}).terratex == "1"
local ECHO_COST = false
local ECHO_DETAILED_COST_ESTIMATE = false

-- Speedups
local cos                   = math.cos
local floor                 = math.floor
local abs                   = math.abs
local pi                    = math.pi
local ceil                  = math.ceil
local sqrt                  = math.sqrt
local pow                   = math.pow
local random                = math.random
local max                   = math.max
local min                   = math.min

local spGetGroundHeight     = Spring.GetGroundHeight
local spGetGroundOrigHeight = Spring.GetGroundOrigHeight
local spGetGroundNormal     = Spring.GetGroundNormal
local spLevelHeightMap      = Spring.LevelHeightMap
local spGetUnitBuildFacing  = Spring.GetUnitBuildFacing
local spGetUnitCommands     = Spring.GetUnitCommands
local spValidUnitID         = Spring.ValidUnitID
local spGetGameFrame        = Spring.GetGameFrame
local spGiveOrderToUnit     = Spring.GiveOrderToUnit
local spInsertUnitCmdDesc   = Spring.InsertUnitCmdDesc
local spSetHeightMap        = Spring.SetHeightMap
local spSetHeightMapFunc    = Spring.SetHeightMapFunc
local spCreateUnit          = Spring.CreateUnit
local spDestroyUnit         = Spring.DestroyUnit
local spGetAllyTeamList     = Spring.GetAllyTeamList
local spSetUnitLosMask      = Spring.SetUnitLosMask
local spSetUnitLosState     = Spring.SetUnitLosState
local spGetTeamInfo         = Spring.GetTeamInfo
local spGetUnitHealth       = Spring.GetUnitHealth
local spSetUnitHealth       = Spring.SetUnitHealth
local spGetUnitTeam         = Spring.GetUnitTeam
local spGetUnitAllyTeam     = Spring.GetUnitAllyTeam
local spAddHeightMap        = Spring.AddHeightMap
local spGetUnitPosition     = Spring.GetUnitPosition
local spSetUnitPosition     = Spring.SetUnitPosition
local spSetUnitSensorRadius = Spring.SetUnitSensorRadius
local spGetUnitIsDead       = Spring.GetUnitIsDead
local spSetUnitRulesParam   = Spring.SetUnitRulesParam

local mapWidth = Game.mapSizeX
local mapHeight = Game.mapSizeZ

local CMD_OPT_RIGHT = CMD.OPT_RIGHT
local CMD_OPT_ALT   = CMD.OPT_ALT
local CMD_REPAIR    = CMD.REPAIR
local CMD_INSERT    = CMD.INSERT

local SQRT_2 = sqrt(2)
local ALLIED_TABLE = {allied = true}

--------------------------------------------------------------------------------
-- Configuration
--------------------------------------------------------------------------------

local bumpyMap = {}

for i = 0, 64, 8 do
	bumpyMap[i] = {}
	for j = 0, 64, 8 do
		bumpyMap[i][j] = 32 - max(abs(i-32), abs(j-32))
	end
end

local maxCommandPoints = 2500
local maxCommandUnits = 1000

local maxAreaSize = 2000 -- max X or Z bound of area terraform
local areaSegMaxSize = 200 -- max width and height of terraform squares

local maxWallPoints = 700 -- max points that can makeup a wall
local wallSegmentLength = 14 -- how many points are part of a wall segment (points are seperated 8 elmos orthagonally)

local maxRampWidth = 200 -- maximun width of ramp segment
local maxRampLegth = 200 -- maximun length of ramp segment

local maxHeightDifference = 28 -- max difference of height around terraforming, Makes Shraka Pyramids
local maxHeightDiffDownInner = 8
local maxEdgeHeightDiff = 4 -- max difference of terraform around the edge of the pyramid
local maxRampGradient = 5

local volumeCost = 0.0128
local pointExtraAreaCost = 0 -- 0.027
local pointExtraAreaCostDepth = 14
local pointExtraPerimeterCost = 0.15
local pointExtraPerimeterCostDepth = 10
local baseTerraunitCost = 6
local inbuiltCostMult = 0.5

local noBuildBaseCost = 3
local baseSpendProp = 0.94

local perimeterEdgeCost = {
	[0] = 0,
	[1] = 1,
	[2] = 1.4,
	[3] = 1,
	[4] = 1,
}
-- cost of a point = volumeCost*diffHeight + extraCost*(extraCostDepth < diffHeight and diffHeight or extraCostDepth)
-- cost of shraka pyramid point = volumeCost*diffHeight

--ramp dimensions
local maxTotalRampLength = 3000
local maxTotalRampWidth = 800
local minTotalRampLength = 64
local minTotalRampWidth = 48

local checkLoopFrames = 1200 -- how many frames it takes to check through all cons
local terraformDecayFrames = 2*60*30 -- how many frames a terrablock can survive for without a repair command
local decayCheckFrequency = 90 -- frequency of terraform decay checks

local structureCheckLoopFrames = 300 -- frequency of slow update for building deformation check

local terraUnitLeash = 100 -- how many elmos a terraunit is allowed to roam

local enemyDistConst = 36 -- Constant added to enemy distinct check
local nearbyEnemyPenalty = 20 -- Cost multiplier for terraform on enemy units

local pyramidLimitExtra = 8 -- Extra limit on pyramid height before terraform is cancelled.

local costMult = 1
local modOptions = Spring.GetModOptions()
if modOptions.terracostmult then
	costMult = modOptions.terracostmult
end

local ENEMY_BLOCK_TERRA = not (tonumber(modOptions.enemyterra) == 1)

volumeCost = volumeCost * costMult * inbuiltCostMult
pointExtraPerimeterCost = pointExtraPerimeterCost * costMult * inbuiltCostMult
pointExtraAreaCost = pointExtraAreaCost * costMult * inbuiltCostMult

--------------------------------------------------------------------------------
-- Arrays
--------------------------------------------------------------------------------

local steepnessMarkers      = {inner = {count = 0, data = {}, frame = 0}}

local structure             = {}
local structureTable        = {}
local structureCount        = 0

local structureAreaMap      = {}

local structureCheckFrame   = {}
local currentCheckFrame     = 0

local terraformUnit         = {}
local terraformUnitTable    = {}
local terraformUnitCount    = 0

local terraformOrder        = {}
local terraformOrders       = 0

local constructor           = {}
local constructorTable      = {}
local constructors          = 0
local currentCon            = 0

local checkInterval         = 0

-- Performance
local MIN_UPDATE_PERIOD     = 6
local MAX_UPDATE_PERIOD     = 40
local updatePeriod          = 20 -- how many frames to update
local terraformOperations   = 0 -- tracks how many operations. Used to prevent slowdown.
local nextUpdateCheck       = 0 -- Time at which to check performance

-- Map terraform commands given by teamID and tag.
local fallbackCommands  = {}

local terraunitDefID = UnitDefNames["terraunit"].id
local terraUnitHP = UnitDefs[terraunitDefID].health - 1000 -- Stop terraunit having full health to make it always able to be built.
local terraUnitCost = UnitDefs[terraunitDefID].metalCost
local terraBuildMult = terraUnitHP/UnitDefs[terraunitDefID].health

local terraformUnitDefIDs = {}
for i = 1, #UnitDefs do
	local ud = UnitDefs[i]
	if ud and ud.isBuilder and not ud.isFactory and (ud.terraformSpeed > 0) then
		terraformUnitDefIDs[i] = true
	end
end

local REPAIR_ORDER_PARAMS = {0, CMD_REPAIR, CMD_OPT_RIGHT, 0} -- static because only the 4th parameter changes

local wantForceCompleteFrameZero = false
local freeTerraform = false
local debugMode = false
local debugModeUnitID

--------------------------------------------------------------------------------
-- Custom Commands
--------------------------------------------------------------------------------

include("LuaRules/Configs/customcmds.h.lua")

local rampCmdDesc = {
	id      = CMD_RAMP,
	type    = CMDTYPE.ICON_MAP,
	name    = 'Ramp',
	cursor  = 'Ramp',
	action  = 'rampground',
	tooltip = 'Build a Ramp - Click and drag between two positions.',
}

local levelCmdDesc = {
	id      = CMD_LEVEL,
	type    = CMDTYPE.ICON_AREA,
	name    = 'Level',
	cursor  = 'Level',
	action  = 'levelground',
	tooltip = 'Level the terrain - Click and drag a line or closed shape.',
}

local raiseCmdDesc = {
	id      = CMD_RAISE,
	type    = CMDTYPE.ICON_AREA,
	name    = 'Raise',
	cursor  = 'Raise',
	action  = 'raiseground',
	tooltip = 'Raises/Lower terrain - Click and drag a line or closed shape.',
}

local smoothCmdDesc = {
	id      = CMD_SMOOTH,
	type    = CMDTYPE.ICON_AREA,
	name    = 'Smooth',
	cursor  = 'Smooth',
	action  = 'smoothground',
	tooltip = 'Smooth the terrain - Click and drag a line or closed shape.',
}

local restoreCmdDesc = {
	id      = CMD_RESTORE,
	type    = CMDTYPE.ICON_AREA,
	name    = 'Restore2',
	cursor  = 'Restore2',
	action  = 'restoreground',
	tooltip = 'Restore the terrain to its original shape - Click and drag a line or closed shape.',
}

local bumpyCmdDesc = {
	id      = CMD_BUMPY,
	type    = CMDTYPE.ICON_AREA,
	name    = 'Bumpify',
	cursor  = 'Repair',
	action  = 'bumpifyground',
	tooltip = 'Makes the ground bumpy',
}

local fallbackableCommands = {
	[CMD_RAMP] = true,
	[CMD_LEVEL] = true,
	[CMD_RAISE] = true,
	[CMD_SMOOTH] = true,
	[CMD_RESTORE] = true,
}

local wantedCommands = {
	[CMD_RAMP] = true,
	[CMD_LEVEL] = true,
	[CMD_RAISE] = true,
	[CMD_SMOOTH] = true,
	[CMD_RESTORE] = true,
	[CMD_TERRAFORM_INTERNAL] = true,
}

local cmdDescsArray = {
	rampCmdDesc,
	levelCmdDesc,
	raiseCmdDesc,
	smoothCmdDesc,
	restoreCmdDesc,
	--bumpyCmdDesc,
}

if (not Game.mapDamage) then  -- map has "notDeformable = true", or "disablemapdamage = 1" modoption was set in the startscript
	include("LuaRules/colors.h.lua")
	local disabledText = '\n' .. RedStr .. "DISABLED" .. PinkStr .. "  (map not deformable)"

	for _, cmdDesc in ipairs(cmdDescsArray) do
		cmdDesc.disabled = true
		cmdDesc.tooltip  = cmdDesc.tooltip .. disabledText
	end
elseif modOptions.terrarestoreonly == "1" then
	include("LuaRules/colors.h.lua")
	local disabledText = '\n' .. RedStr .. "DISABLED" .. PinkStr .. "  (only restore allowed)"

	for _, cmdDesc in ipairs(cmdDescsArray) do
		if cmdDesc ~= restoreCmdDesc then
			cmdDesc.disabled = true
			cmdDesc.tooltip  = cmdDesc.tooltip .. disabledText
		end
	end
end

--------------------------------------------------------------------------------
-- Structure Utilities
--------------------------------------------------------------------------------

local function AddStructure(unitID, i, j)
	local k = 1
	while structureAreaMap[k] and structureAreaMap[k][i] and structureAreaMap[k][i][j] do
		k = k + 1
	end
	if not structureAreaMap[k] then
		structureAreaMap[k] = {}
	end
	if not structureAreaMap[k][i] then
		structureAreaMap[k][i] = {}
	end
	structureAreaMap[k][i][j] = unitID
end

local function RemoveStructure(unitID, i, j)
	local k = 1
	local index
	while structureAreaMap[k] and structureAreaMap[k][i] and structureAreaMap[k][i][j] do
		if structureAreaMap[k][i][j] == unitID then
			index = k
		end
		k = k + 1
	end
	if not index then
		Spring.Echo("LUA_ERRRUN", "Structure removal failure:", unitID, k, "i, j:", i, j)
		return
	end
	local structCount = k - 1
	if index == 1 and structCount == 1 then
		structureAreaMap[structCount][i][j] = nil
		return
	end
	structureAreaMap[index][i][j] = structureAreaMap[structCount][i][j]
	structureAreaMap[structCount][i][j] = nil
end

local function HasStructure(i, j)
	return structureAreaMap[1] and structureAreaMap[1][i] and structureAreaMap[1][i][j]
end

--------------------------------------------------------------------------------
-- New Functions
--------------------------------------------------------------------------------

local unitAlreadyEchoed = {}
local function EchoUnit(unitID)
	if debugMode and not unitAlreadyEchoed[unitID] and ((not debugModeUnitID) or debugModeUnitID[unitID]) then
		Spring.Utilities.UnitEcho(unitID, unitID)
		unitAlreadyEchoed[unitID] = true
	end
end

local function IsDebug(unitID)
	return debugMode and ((not debugModeUnitID) or debugModeUnitID[unitID])
end

local function EchoDebug(unitID, ...)
	if IsDebug(unitID) then
		Spring.Echo(unitID, ...)
	end
end

local function IsBadNumber(value, thingToSay)
	local isBad = (string.find(tostring(value), "n") and true) or false
	if isBad then
		Spring.Echo("Terraform bad number detected", thingToSay, value)
	end
	return isBad
end

local function SetTooltip(unitID, spent, estimatedCost)
	Spring.SetUnitRulesParam(unitID, "terraform_spent", spent, ALLIED_TABLE)
	if IsBadNumber(estimatedCost, "SetTooltip") then
		estimatedCost = 100 -- the estimate is for widgets only so better to have wrong data than to crash
	end
	Spring.SetUnitRulesParam(unitID, "terraform_estimate", estimatedCost, ALLIED_TABLE)
end

local function IsPositionTerraformable(x, z, ignoreStructure)
	if (not ignoreStructure) and HasStructure(x, z) then
		return false
	end
	if GG.map_AllowPositionTerraform then
		return GG.map_AllowPositionTerraform(x, z)
	end
	return true
end

local function SetupPointStructure(point, structArea, segArea)
	local currHeight = point.orHeight
	local x, z = point.x, point.z
	if (structArea[x] and structArea[x][z]) or (GG.map_AllowPositionTerraform and not GG.map_AllowPositionTerraform(x, z)) then
		point.diffHeight = 0.0001
		point.structure = structArea[x][z] or 1000
	else
		point.diffHeight = point.aimHeight - currHeight
		segArea[x][z] = {orHeight = point.orHeight, diffHeight = point.diffHeight, building = false}
	end
end

local function GetGroundOrigHeightOverride(x, z, xOff, zOff)
	if GG.mapgen_origHeight and GG.mapgen_origHeight[x] and GG.mapgen_origHeight[x][z] then
		return GG.mapgen_origHeight[x][z] - (Spring.GetGameRulesParam("waterlevel") or 0)
	end
	return spGetGroundOrigHeight(x +  (xOff or 0), z + (zOff or 0))
end

--------------------------------------------------------------------------------
-- Enemy Terraform Blocking
--------------------------------------------------------------------------------

local function CheckNearbyEnemy(unitID)
	if not ENEMY_BLOCK_TERRA then
		return
	end
	local nearbyEnemyID = Spring.GetUnitNearestEnemy(unitID, terraformUnit[unitID].enemyCheckDist, true)
	local nearbyEnemy = (nearbyEnemyID and true) or false
	if IsDebug(unitID) then
		Spring.Echo("nearbyEnemy", nearbyEnemy, math.random())
		if nearbyEnemyID then
			Spring.Utilities.UnitEcho(nearbyEnemyID, "")
		end
	end
	if nearbyEnemy ~= terraformUnit[unitID].nearbyEnemy then
		spSetUnitRulesParam(unitID, "terraform_enemy", (nearbyEnemy and nearbyEnemyID) or -1, ALLIED_TABLE)
		terraformUnit[unitID].nearbyEnemy = nearbyEnemy
		Spring.SetUnitCosts(unitID, {buildTime = terraUnitCost*((nearbyEnemy and nearbyEnemyPenalty) or 1)})
		EchoDebug(unitID, "SetUnitCosts mult", ((nearbyEnemy and nearbyEnemyPenalty) or 1))
	end
end

local function InitialiseNearbyEnemy(unitID)
	local data = terraformUnit[unitID]
	local size = math.sqrt((data.border.bottom - data.border.top)^2 + (data.border.right - data.border.left)^2)
	data.enemyCheckDist = size*0.5 + terraUnitLeash + enemyDistConst
	EchoDebug(unitID, "enemyCheckDist", data.enemyCheckDist)
	
	CheckNearbyEnemy(unitID)
end

--------------------------------------------------------------------------------
-- Terraform Calculation Functions
--------------------------------------------------------------------------------

local function linearEquation(x,m,x1,y1)
	return m*(x-x1)+y1
end

local function distance(x1,y1,x2,y2)
	return ((x1-x2)^2+(y1-y2)^2)^0.5
end

local function pointHeight(xs, ys, zs, x, z, m, h, xdis)
	local xInt = (z-zs+m*xs+x/m)/(m+1/m)
	local ratio = abs(xInt-xs)/xdis
	return ratio*h+ys
end

local function bumpyFunc(x,z,bumpyType)
	local sign = pow(-1,((x - x%64)/64 + (z - z%64)/64))
	--return pow(-1,((x - x%8)/8 + (z - z%8)/8))*3*(bumpyType + 1)
	return bumpyMap[x%64][z%64]*sign*(bumpyType + 1)
end

local function checkPointCreation(terraform_type, volumeSelection, orHeight, newHeight, startHeight, x, z)
	if terraform_type == 6 then
		local _, ny, _ = spGetGroundNormal(x,z)
		if ny > select(2,spGetGroundNormal(x+8,z)) then
			ny = select(2,spGetGroundNormal(x+8,z))
		end
		if ny > select(2,spGetGroundNormal(x-8,z)) then
			ny = select(2,spGetGroundNormal(x-8,z))
		end
		if ny > select(2,spGetGroundNormal(x,z+8)) then
			ny = select(2,spGetGroundNormal(x,z+8))
		end
		if ny > select(2,spGetGroundNormal(x,z-8)) then
			ny = select(2,spGetGroundNormal(x,z-8))
		end
		--if (volumeSelection == 1 and ny > 0.595) or ny > 0.894 then
		--    Spring.MarkerAddLine(x,0,z,x+8,0,z+8)
		--    Spring.MarkerAddLine(x+8,0,z,x,0,z+8)
		--end
		return (volumeSelection == 1 and ny > 0.595) or ny > 0.894
	end
	
	if volumeSelection == 0 or terraform_type == 2 then
		return true
	end
	
	if abs(orHeight-newHeight) == 0 then
		return false
	end

	if terraform_type == 5 then
		return (volumeSelection == 1 and orHeight < startHeight) or (volumeSelection == 2 and orHeight > startHeight)
	else
		return (volumeSelection == 1 and orHeight < newHeight) or (volumeSelection == 2 and orHeight > newHeight)
	end
end

local function updateBorderWithPoint(border, x, z)
	if x < border.left then
		border.left = x
	end
	if x > border.right then
		border.right = x
	end
	if z < border.top then
		border.top = z
	end
	if z > border.bottom then
		border.bottom = z
	end
end

local function getPointInsideMap(x,z)
	if x < 1 then
		x = 1
	end
	if x > mapWidth-1 then
		x = mapWidth-1
	end
	if z < 1 then
		z = 1
	end
	if z > mapHeight-1 then
		z = mapHeight-1
	end
	return x, z
end

local function SetInivisbleToEnemy(unitID, team)
	local allyTeamList = spGetAllyTeamList()
	local _,_,_,_,_,unitAllyTeam = spGetTeamInfo(team, false)
	for i=1, #allyTeamList do
		local allyID = allyTeamList[i]
		if allyID ~= unitAllyTeam then
			spSetUnitLosState(unitID, allyID, 0)
			spSetUnitLosMask(unitID, allyID, 15)
		end
	end
end

local function setupTerraunit(unitID, team, x, y, z)
	y = y or CallAsTeam(team, function () return spGetGroundHeight(x,z) end)

	Spring.MoveCtrl.Enable(unitID)
	Spring.MoveCtrl.SetPosition(unitID, x, y or 0, z)
	Spring.MoveCtrl.Disable(unitID)
	
	spSetUnitSensorRadius(unitID,"los",0) -- REMOVE IN 0.83
	spSetUnitSensorRadius(unitID,"airLos",0) -- REMOVE IN 0.83
	SetInivisbleToEnemy(unitID, team)

	spSetUnitHealth(unitID, {
		health = 0.01,
		build  = 0
	})
end

local function GetTerraunitLeashedSpot(teamID, anchorX, anchorZ, biasX, biasZ)
	local x, z

	local vx = biasX - anchorX
	local vz = biasZ - anchorZ

	local leashLength = sqrt(vx*vx + vz*vz)
	if leashLength > terraUnitLeash then
		-- cruel leash!
		local leashScale = terraUnitLeash / leashLength
		x = anchorX + leashScale * vx
		z = anchorZ + leashScale * vz
	else
		x = biasX
		z = biasZ
	end

	x, z = getPointInsideMap(x, z)
	local y = CallAsTeam(teamID, spGetGroundHeight, x, z)

	return x, y, z
end

local function AddFallbackCommand(teamID, commandTag, terraunits, terraunitList, commandX, commandZ)
	fallbackCommands[teamID] = fallbackCommands[teamID] or {}
	
	fallbackCommands[teamID][commandTag] = {
		terraunits = terraunits,
		terraunitList = terraunitList,
		commandX = commandX,
		commandZ = commandZ,
	}
end

local function GetUnitAveragePosition(unit, units)
	if not unit then
		return
	end
	local unitsX = 0
	local unitsZ = 0
	local i = 1
	while i <= units do
		if (spValidUnitID(unit[i])) then
			local x,_,z = spGetUnitPosition(unit[i])
			unitsX = unitsX + x
			unitsZ = unitsZ + z
			i = i + 1
		else
			unit[i] = unit[units]
			unit[units] = nil
			units = units - 1
		end
	end
		
	if units == 0 then
		return
	end
	
	return unitsX/units, unitsZ/units
end

local function TerraformRamp(x1, y1, z1, x2, y2, z2, terraform_width, unit, units, team, volumeSelection, shift, commandX, commandZ, commandTag, disableForceCompletion, noDecay)
	--** Initial constructor processing **
	local unitsX, unitsZ = GetUnitAveragePosition(unit, units)
	if not unitsX then
		unitsX, unitsZ = commandX, commandZ
	end
	
	--calculate equations of the 3 lines, left, right and mid
	
	local border = {}
	
	if abs(x1 - x2) < 0.1 then
		x2 = x1 + 0.1
	end
	if abs(z1 - z2) < 0.1 then
		z2 = z1 + 0.1
	end

	local dis = distance(x1,z1,x2,z2)
	
	if dis < minTotalRampLength-0.05 or dis > maxTotalRampLength+0.05 then
		return
	end
	
	if terraform_width < minTotalRampWidth or terraform_width > maxTotalRampWidth*2 then
		return
	end

	local xdis = abs(x1-x2)
	local heightDiff = y2-y1
	if heightDiff/dis > maxRampGradient then
		heightDiff = maxRampGradient*dis
	elseif heightDiff/dis < -maxRampGradient then
		heightDiff = -maxRampGradient*dis
	end
	
	-- Due to previous checks, m is not 0 or infinity.
	local m = (z1-z2)/(x1-x2)
	
	local segmentsAlong = ceil(dis/maxRampLegth)
	local segmentsAcross = ceil(terraform_width/maxRampWidth)
	local segLength = dis/segmentsAlong
	local segWidth = terraform_width/segmentsAcross
	local widthScale = terraform_width/dis
	local lengthScale = segLength/dis

	local add = {x = (x2-x1)*lengthScale, z = (z2-z1)*lengthScale}
	local addPerp = {x = (z1-z2)*segWidth/dis, z = -(x1-x2)*segWidth/dis}
	
	local mid = {x = (x1-x2)*widthScale/2, z = (z1-z2)*widthScale/2}
	local leftRot = {x = mid.z+x1, z = -mid.x+z1}
	local rightRot = {x = -mid.z+x1, z = mid.x+z1}

	--Spring.MarkerAddPoint(leftRot.x,0,leftRot.z,"L")
	--Spring.MarkerAddPoint(rightRot.x,0,rightRot.z,"R")
	--Spring.MarkerAddPoint(rightRot.x+add.x,0,rightRot.z+add.z,"R + A")
	--Spring.MarkerAddPoint(rightRot.x+addPerp.x,0,rightRot.z+addPerp.z,"R + AP")
	
	local topleftGrad
	local botleftGrad

	local toppoint
	local botpoint
	local leftpoint
	local rightpoint
	
	--** Store the 4 points of each segment diamond, changes with quadrant **
	
	if x1 < x2 then
		if z1 < z2 then
			-- bottom right
			topleftGrad = -1/m
			botleftGrad = m
			
			toppoint = rightRot
			leftpoint = {x = rightRot.x+addPerp.x, z = rightRot.z+addPerp.z}
			rightpoint = {x = toppoint.x+add.x, z = toppoint.z+add.z}
			botpoint = {x = leftpoint.x+add.x, z = leftpoint.z+add.z}
			
			border = {left = leftRot.x, right = rightRot.x-x1+x2, top = rightRot.z, bottom = leftRot.z-z1+z2}
		else
			-- top right
			topleftGrad = m
			botleftGrad = -1/m
			
			leftpoint = rightRot
			botpoint = {x = rightRot.x+addPerp.x, z = rightRot.z+addPerp.z}
			rightpoint = {x = botpoint.x+add.x, z = botpoint.z+add.z}
			toppoint = {x =  rightRot.x+add.x, z =  rightRot.z+add.z}
			
			border = {left = rightRot.x, right = leftRot.x-x1+x2, top = rightRot.z-z1+z2, bottom = leftRot.z}
		end
	else
		if z1 < z2 then
			-- bottom left
			topleftGrad = m
			botleftGrad = -1/m
	  
			rightpoint = rightRot
			toppoint = {x = rightRot.x+addPerp.x, z = rightRot.z+addPerp.z}
			botpoint = {x = rightRot.x+add.x, z = rightRot.z+add.z}
			leftpoint = {x = toppoint.x+add.x, z = toppoint.z+add.z}
			
			border = {left = leftRot.x-x1+x2, right = rightRot.x, top = rightRot.z-z1+z2, bottom = leftRot.z}
		else
			-- top left
			topleftGrad = -1/m
			botleftGrad = m
			
			botpoint = rightRot
			rightpoint = {x = rightRot.x+addPerp.x, z = rightRot.z+addPerp.z}
			toppoint = {x = rightpoint.x+add.x, z = rightpoint.z+add.z}
			leftpoint = {x = rightRot.x+add.x, z = rightRot.z+add.z}
			
			border = {left = rightRot.x-x1+x2, right = leftRot.x, top = leftRot.z-z1+z2, bottom = rightRot.z}
		end
	end
	-- check it's all working
	
	--[[
	Spring.MarkerAddPoint( border.left,0,border.top,"topleft")
	Spring.MarkerAddPoint( border.right,0,border.bottom,"botright")
	Spring.MarkerAddPoint( x1,y1,z1,  "start")
	Spring.MarkerAddPoint( x2,y2,z2,  "end")
	Spring.MarkerAddPoint( leftpoint.x,y1,leftpoint.z,  "leftP")
	Spring.MarkerAddPoint( toppoint.x,y1,toppoint.z,  "topP")
	Spring.MarkerAddPoint( botpoint.x,y1,botpoint.z,  "botP")
	Spring.MarkerAddPoint( leftpoint.x,y1,toppoint.z,  "topleft")
	Spring.MarkerAddPoint( rightpoint.x,y1,botpoint.z,  "botright")
	  
	Spring.MarkerAddLine(toppoint.x,y1,toppoint.z,leftpoint.x,y1,leftpoint.z)
	Spring.MarkerAddLine(botpoint.x,y1,botpoint.z,leftpoint.x,y1,leftpoint.z)
	Spring.MarkerAddLine(toppoint.x,y1,toppoint.z,rightpoint.x,y1,rightpoint.z)
	Spring.MarkerAddLine(botpoint.x,y1,botpoint.z,rightpoint.x,y1,rightpoint.z)

	Spring.MarkerAddLine(leftpoint.x,y1,toppoint.z,rightpoint.x,y1,toppoint.z)
	Spring.MarkerAddLine(rightpoint.x,y1,toppoint.z,rightpoint.x,y1,botpoint.z)
	Spring.MarkerAddLine(leftpoint.x,y1,toppoint.z,leftpoint.x,y1,botpoint.z)
	Spring.MarkerAddLine(leftpoint.x,y1,botpoint.z,rightpoint.x,y1,botpoint.z)
	--]]

	--** Split the ramp into segments and calculate the points within each one**
	local segment = {}
	local n = 1
	
	do local i = 0
	while i < segmentsAlong do
		local j = 0
		while j < segmentsAcross do
			local middleSegment = (i > 0) and (j > 0) and (i < segmentsAlong - 1) and (j < segmentsAcross - 1)
			local offset = (middleSegment and 8) or 0
			
			segment[n] = {}
			segment[n].along = i
			segment[n].point = {}
			segment[n].area = {}
			segment[n].border = {
				left = floor((leftpoint.x+add.x*i+addPerp.x*j)/8)*8 - offset,
				right = ceil((rightpoint.x+add.x*i+addPerp.x*j)/8)*8 + offset,
				top = floor((toppoint.z+add.z*i+addPerp.z*j)/8)*8 - offset,
				bottom = ceil((botpoint.z+add.z*i+addPerp.z*j)/8)*8 + offset
			}
			-- end of segment
			--segment[n].position = {x = (rightRot.x-4+add.x*i+addPerp.x*(j+0.5)-16*(x2-x1)/dis), z = (rightRot.z-4+add.z*i+addPerp.z*(j+0.5)-16*(z2-z1)/dis)}
			
			-- middle of segment
			segment[n].position = {x = rightRot.x+add.x*(i+0.5)+addPerp.x*(j+0.5), z = rightRot.z+add.z*(i+0.5)+addPerp.z*(j+0.5)}
			local pc = 1
		  
			local topline1 = {x = leftpoint.x+add.x*i+addPerp.x*j - offset, z = leftpoint.z+add.z*i+addPerp.z*j - offset, m = topleftGrad}
			local topline2 = {x = toppoint.x+add.x*i+addPerp.x*j + offset, z = toppoint.z+add.z*i+addPerp.z*j - offset, m = botleftGrad}
			local botline1 = {x = leftpoint.x+add.x*i+addPerp.x*j - offset, z = leftpoint.z+add.z*i+addPerp.z*j + offset, m = botleftGrad}
			local botline2 = {x = botpoint.x+add.x*i+addPerp.x*j + offset, z = botpoint.z+add.z*i+addPerp.z*j + offset, m = topleftGrad}
			
			local topline = topline1
			local botline = botline1
			
			local lx = segment[n].border.left - offset
			while lx <= segment[n].border.right + offset do
				segment[n].area[lx] = {}
				local zmin = linearEquation(lx,topline.m,topline.x,topline.z)
				local zmax = linearEquation(lx,botline.m,botline.x,botline.z)
				
				local lz = segment[n].border.top
				while lz <= zmax do
					if zmin <= lz then
						local h = pointHeight(x1, y1, z1, lx, lz, m, heightDiff, xdis)
						local orHeight = spGetGroundHeight(lx,lz)
						if checkPointCreation(4, volumeSelection, orHeight, h, 0, lx, lz) then
							segment[n].point[pc] = {x = lx, y = h ,z = lz, orHeight = orHeight, prevHeight = spGetGroundHeight(lx,lz)}
							pc = pc + 1
						end
					end
					lz = lz+8
				end
				lx = lx+8
			  
				if topline == topline1 and topline2.x < lx then
					topline = topline2
				end
			  
				if botline == botline1 and botline2.x < lx then
					botline = botline2
				end
			end
			
			if pc ~= 1 then
				segment[n].points = pc - 1
				n = n + 1
			end
			j = j+1
		end
		i = i+1
	end end
	
	--** Detect potentially overlapping buildings**
	
	local localStructure = {}
	local localStructureCount = 0
	
	for i = 1, structureCount do
		local s = structure[structureTable[i] ]
		if (border.left < s.maxx and
			border.right > s.minx and
			border.top < s.maxz and
			border.bottom > s.minz) then
			
			localStructureCount = localStructureCount + 1
			localStructure[localStructureCount] = i
		end
	end

	--** Creates terraform building and assigns each one segment data **
		
	local block = {}
	local blocks = 0
	
	terraformOrders = terraformOrders + 1
	terraformOrder[terraformOrders] = {border = border, index = {}, indexes = 0}
	
	local rampLevels = {count = 0, data = {[0] = {along = false}}}
	
	local frame = spGetGameFrame()
	
	for i = 1,n-1 do
		-- detect overlapping buildings
		
		segment[i].structure = {}
		segment[i].structureCount = 0
		segment[i].structureArea = {}
		
		for j = 1, localStructureCount do
			local s = structure[structureTable[localStructure[j]]]
			if (segment[i].border.left < s.maxx and
				segment[i].border.right > s.minx and
				segment[i].border.top < s.maxz and
				segment[i].border.bottom > s.minz) then
				
				segment[i].structureCount = segment[i].structureCount + 1
				segment[i].structure[segment[i].structureCount] = {id = s}
				
				s.checkAtDeath = true
				
				for lx = s.minx, s.maxx, 8 do
					if not segment[i].structureArea[lx] then
						segment[i].structureArea[lx] = {}
					end
					for lz = s.minz,s.maxz, 8 do
						segment[i].structureArea[lx][lz] = (segment[i].structureArea[lx][lz] or 0) + 1
					end
				end
				
			end
		end
	
		-- calculate cost
		local totalCost = 0
		local areaCost = 0
		local perimeterCost = 0
		
		for j = 1, segment[i].points do
			if not segment[i].area[segment[i].point[j].x] then
				segment[i].area[segment[i].point[j].x] = {}
			end
			segment[i].point[j].aimHeight = segment[i].point[j].y
			SetupPointStructure(segment[i].point[j], segment[i].structureArea, segment[i].area)
			totalCost = totalCost + abs(segment[i].point[j].diffHeight)
			areaCost = areaCost + (pointExtraAreaCostDepth > abs(segment[i].point[j].diffHeight) and abs(segment[i].point[j].diffHeight) or pointExtraAreaCostDepth)
		end
		
		-- Perimeter Cost
		local pyramidCostEstimate = 0
		
		for j = 1, segment[i].points do
			local x = segment[i].point[j].x
			local z = segment[i].point[j].z
			
			if segment[i].area[x] and segment[i].area[x][z] then
				
				local edgeCount = 0
				
				if (not segment[i].area[x+8]) or (not segment[i].area[x+8][z]) then
					edgeCount = edgeCount + 1
				end
				if (not segment[i].area[x-8]) or (not segment[i].area[x-8][z]) then
					edgeCount = edgeCount + 1
				end
				if (not segment[i].area[x][z+8]) then
					edgeCount = edgeCount + 1
				end
				if (not segment[i].area[x][z-8]) then
					edgeCount = edgeCount + 1
				end
				
				if perimeterEdgeCost[edgeCount] > 0 then
					perimeterCost = perimeterCost + perimeterEdgeCost[edgeCount]*(pointExtraPerimeterCostDepth > abs(segment[i].point[j].diffHeight) and abs(segment[i].point[j].diffHeight) or pointExtraPerimeterCostDepth)
				end
				
				if edgeCount > 0 then
					local height = abs(segment[i].point[j].diffHeight)
					if height > 30 then
						pyramidCostEstimate = pyramidCostEstimate + ((height - height%maxHeightDifference)*(floor(height/maxHeightDifference)-1)*0.5 + floor(height/maxHeightDifference)*(height%maxHeightDifference))*volumeCost
					end
				end
			end
		end
		
		if totalCost ~= 0 then
			local baseCost = areaCost*pointExtraAreaCost + perimeterCost*pointExtraPerimeterCost + baseTerraunitCost
			totalCost = totalCost*volumeCost + baseCost
			
			if ECHO_DETAILED_COST_ESTIMATE then
				Spring.Echo("Total Cost", totalCost, "Area Cost", areaCost*pointExtraAreaCost, "Perimeter Cost", perimeterCost*pointExtraPerimeterCost)
			end
			local pos = segment[i].position
			local terraunitX, teamY, terraunitZ = GetTerraunitLeashedSpot(team, pos.x, pos.z, unitsX, unitsZ)
			
			local id = spCreateUnit(terraunitDefID, terraunitX, teamY or 0, terraunitZ, 0, team, true)
			
			if id then
				spSetUnitHealth(id, 0.01)
				if segment[i].along ~= rampLevels.data[rampLevels.count].along then
					rampLevels.count = rampLevels.count + 1
					rampLevels.data[rampLevels.count] = {along = segment[i].along, count = 0, data = {}}
				end
				rampLevels.data[rampLevels.count].count = rampLevels.data[rampLevels.count].count + 1
				rampLevels.data[rampLevels.count].data[rampLevels.data[rampLevels.count].count] = id

				setupTerraunit(id, team, terraunitX, false, terraunitZ)
				spSetUnitRulesParam(id, "terraformType", 4) --ramp
			
				blocks = blocks + 1
				block[blocks] = id

				terraformUnitCount = terraformUnitCount + 1
				terraformOrder[terraformOrders].indexes = terraformOrder[terraformOrders].indexes + 1
				
				terraformUnit[id] = {
					positionAnchor = pos,
					position = {x = terraunitX, z = terraunitZ},
					progress = 0,
					lastUpdate = 0,
					totalSpent = 0,
					volCostSpent = 0,
					baseCostSpent = 0,
					zeroProgressCost = 0,
					cost = totalCost,
					baseCost = baseCost,
					totalCost = totalCost,
					pyramidCostEstimate = pyramidCostEstimate,
					point = segment[i].point,
					points = segment[i].points,
					area = segment[i].area,
					border = segment[i].border,
					smooth = false,
					intercepts = 0,
					intercept = {},
					interceptMap = {},
					decayTime = frame + terraformDecayFrames,
					allyTeam = unitAllyTeam,
					team = team,
					order = terraformOrders,
					orderIndex = terraformOrder[terraformOrders].indexes,
					fullyInitialised = false,
					lastProgress = 0,
					lastHealth = 0,
					disableForceCompletion = disableForceCompletion,
					noDecay = noDecay,
				}
				InitialiseNearbyEnemy(id)
				
				terraformUnitTable[terraformUnitCount] = id
				terraformOrder[terraformOrders].index[terraformOrder[terraformOrders].indexes] = terraformUnitCount
				
				SetTooltip(id, 0, pyramidCostEstimate + totalCost)
			end
		end
		
	end
	--** Give repair order for each block to all selected units **
	if rampLevels.count == 0 then
		return
	end

	local orderList = {data = {}, count = 0}
	
	local zig = 0
	if linearEquation(unitsX,m,x1,z1) < unitsZ then
		zig = 1
	end
	
	for i = 1, rampLevels.count do
		for j = 1 + rampLevels.data[i].count*zig, (rampLevels.data[i].count-1)*(1-zig) + 1, 1-zig*2 do
			orderList.count = orderList.count + 1
			orderList.data[orderList.count] = rampLevels.data[i].data[j]
		end
		zig = 1-zig
	end
	
	if orderList.count == 0 then
		return
	end
	
	AddFallbackCommand(team, commandTag, orderList.count, orderList.data, commandX, commandZ)
end

local function TerraformWall(terraform_type, mPoint, mPoints, terraformHeight, unit, units, team, volumeSelection, shift, commandX, commandZ, commandTag, disableForceCompletion, noDecay)
	local border = {left = mapWidth, right = 0, top = mapHeight, bottom = 0}
	
	--** Initial constructor processing **
	local unitsX, unitsZ = GetUnitAveragePosition(unit, units)
	if not unitsX then
		unitsX, unitsZ = commandX, commandZ
	end
	
	
	--** Convert Mouse Points to a Closed Loop on a Grid **

	-- points interpolated from mouse points
	local point = {}
	local points = 1
	
	mPoint[1].x = floor((mPoint[1].x+8)/16)*16
	mPoint[1].z = floor((mPoint[1].z+8)/16)*16
	point[1] = mPoint[1]
	updateBorderWithPoint(border, point[points].x, point[points].z)
	
	for i = 2, mPoints, 1 do
		mPoint[i].x = floor((mPoint[i].x+8)/16)*16
		mPoint[i].z = floor((mPoint[i].z+8)/16)*16
		
		local diffX = mPoint[i].x - mPoint[i-1].x
		local diffZ = mPoint[i].z - mPoint[i-1].z
		local a_diffX = abs(diffX)
		local a_diffZ = abs(diffZ)
			
		if a_diffX <= 16 and a_diffZ <= 16 then
			points = points + 1
			point[points] = {x = mPoint[i].x, z = mPoint[i].z}
			updateBorderWithPoint(border, point[points].x, point[points].z)
		else
			-- interpolate between far apart points to prevent wall holes.
			if a_diffX > a_diffZ then
				local m = diffZ/diffX
				local sign = diffX/a_diffX
				for j = 0, a_diffX, 16 do
					points = points + 1
					point[points] = {x = mPoint[i-1].x + j*sign, z = floor((mPoint[i-1].z + j*m*sign)/16)*16}
					updateBorderWithPoint(border, point[points].x, point[points].z)
				end
			else
				local m = diffX/diffZ
				local sign = diffZ/a_diffZ
				for j = 0, a_diffZ, 16 do
					points = points + 1
					point[points] = {x = floor((mPoint[i-1].x + j*m*sign)/16)*16, z = mPoint[i-1].z + j*sign}
					updateBorderWithPoint(border, point[points].x, point[points].z)
				end
			end
		end
		
		if points > maxWallPoints then
			-- cancel command if the wall is too big, anti-slowdown
			return false
		end
	end
	
	border.left = border.left - 16
	border.top = border.top - 16
	border.right = border.right + 16
	border.bottom = border.bottom + 16

	--** Split the mouse points into segments **
	
	-- area checks for overlap
	local area = {}
	
	for i = border.left,border.right,8 do
		area[i] = {}
	end
	
	local segment = {}
	local n = 1
	local count = 0
	local continue = true
	
	while continue do
		if count*wallSegmentLength+1 <= points then
			segment[n] = {}
			segment[n].point = {}
			segment[n].area = {}
			segment[n].border = {left = mapWidth, right = 0, top = mapHeight, bottom = 0}
			segment[n].position = {x = point[count*wallSegmentLength+1].x, z = point[count*wallSegmentLength+1].z}
			
			local averagePosition = {x = 0, z = 0, n = 0}
			
			local pc = 1
			
			for j = count*wallSegmentLength+1, (count+1)*wallSegmentLength do
			
				if j > points then
					continue = false
					break
				else
					
					averagePosition.x = averagePosition.x + point[j].x
					averagePosition.z = averagePosition.z + point[j].z
					averagePosition.n = averagePosition.n + 1
					
					for lx = -16,16,8 do
						for lz = -16,16,8 do
							-- lx/lz steps through the points around the mousePoint
							if not area[point[j].x+lx][point[j].z+lz] then
								-- check if the point will be terraformed be a previous block
								segment[n].point[pc] = {x = point[j].x+lx, z = point[j].z+lz}
								area[point[j].x+lx][point[j].z+lz] = true
								-- update border
								updateBorderWithPoint(segment[n].border, segment[n].point[pc].x, segment[n].point[pc].z)
								--[[if segment[n].point[pc].x-16 < .left then
									segment[n].border.left = segment[n].point[pc].x-16
								end
								if segment[n].point[pc].x+16 > segment[n].border.right then
									segment[n].border.right = segment[n].point[pc].x+16
								end
								if segment[n].point[pc].z-16 < segment[n].border.top then
									segment[n].border.top = segment[n].point[pc].z-16
								end
								if segment[n].point[pc].z+16 > segment[n].border.bottom then
									segment[n].border.bottom = segment[n].point[pc].z+16
								end--]]
								local currHeight = spGetGroundHeight(segment[n].point[pc].x, segment[n].point[pc].z)
								segment[n].point[pc].orHeight = currHeight
								segment[n].point[pc].prevHeight = currHeight
								if checkPointCreation(terraform_type, volumeSelection, currHeight, terraformHeight,
										GetGroundOrigHeightOverride(segment[n].point[pc].x, segment[n].point[pc].z),segment[n].point[pc].x, segment[n].point[pc].z) then
									pc = pc + 1
								end
							end
						end
					end
					
				end
			
			end
			
			-- discard segments with no new terraforming
			if pc ~= 1 then
				segment[n].position = {x = averagePosition.x/averagePosition.n, z = averagePosition.z/averagePosition.n}
				segment[n].points = pc - 1
				n = n + 1
			end
			count = count + 1
		else
			continue = false
		end
	end
	
	--** Detect potentially overlapping buildings**
	
	local localStructure = {}
	local localStructureCount = 0
	
	for i = 1, structureCount do
		local s = structure[structureTable[i]]
		if (border.left < s.maxx and
			border.right > s.minx and
			border.top < s.maxz and
			border.bottom > s.minz) then
			
			localStructureCount = localStructureCount + 1
			localStructure[localStructureCount] = i
		end
	end
	

	--** Creates terraform building and assigns each one segment data **
	
	local block = {}
	local blocks = 0
	
	terraformOrders = terraformOrders + 1
	terraformOrder[terraformOrders] = {border = border, index = {}, indexes = 0}
	
	local frame = spGetGameFrame()

	for i = 1,n-1 do
		-- detect overlapping buildings
		segment[i].structure = {}
		segment[i].structureCount = 0
		segment[i].structureArea = {}
		
		for j = 1, localStructureCount do
			local s = structure[structureTable[localStructure[j]]]
			if (segment[i].border.left < s.maxx and
				segment[i].border.right > s.minx and
				segment[i].border.top < s.maxz and
				segment[i].border.bottom > s.minz) then
				
				segment[i].structureCount = segment[i].structureCount + 1
				segment[i].structure[segment[i].structureCount] = {id = s}
				
				s.checkAtDeath = true
				
				for lx = s.minx, s.maxx, 8 do
					if not segment[i].structureArea[lx] then
						segment[i].structureArea[lx] = {}
					end
					for lz = s.minz,s.maxz, 8 do
						segment[i].structureArea[lx][lz] = (segment[i].structureArea[lx][lz] or 0) + 1
					end
				end
				
			end
		end
		
		-- calculate cost
		local totalCost = 0
		local areaCost = 0
		local perimeterCost = 0
		local absTerraformHeight = abs(terraformHeight)
		
		if terraform_type == 1 then
			for j = 1, segment[i].points do
				if not segment[i].area[segment[i].point[j].x] then
					segment[i].area[segment[i].point[j].x] = {}
				end
				segment[i].point[j].aimHeight = terraformHeight
				SetupPointStructure(segment[i].point[j], segment[i].structureArea, segment[i].area)
				
				totalCost = totalCost + abs(segment[i].point[j].diffHeight)
				areaCost = areaCost + (pointExtraAreaCostDepth > abs(segment[i].point[j].diffHeight) and abs(segment[i].point[j].diffHeight) or pointExtraAreaCostDepth)
				if not segment[i].area[segment[i].point[j].x] then
					segment[i].area[segment[i].point[j].x] = {}
				end
			end
		elseif terraform_type == 2 then
			for j = 1, segment[i].points do
				if not segment[i].area[segment[i].point[j].x] then
					segment[i].area[segment[i].point[j].x] = {}
				end
				segment[i].point[j].aimHeight = terraformHeight + segment[i].point[j].orHeight
				SetupPointStructure(segment[i].point[j], segment[i].structureArea, segment[i].area)
				
				totalCost = totalCost + absTerraformHeight
				areaCost = areaCost + (pointExtraAreaCostDepth > abs(segment[i].point[j].diffHeight) and abs(segment[i].point[j].diffHeight) or pointExtraAreaCostDepth)
				if not segment[i].area[segment[i].point[j].x] then
					segment[i].area[segment[i].point[j].x] = {}
				end
			end
		elseif terraform_type == 3 then
			for j = 1, segment[i].points do
				local totalHeight = 0
				for lx = -16, 16,8 do
					for lz = -16, 16,8 do
						totalHeight = totalHeight + spGetGroundHeight(segment[i].point[j].x+lx, segment[i].point[j].z+lz)
					end
				end
				if not segment[i].area[segment[i].point[j].x] then
					segment[i].area[segment[i].point[j].x] = {}
				end
				segment[i].point[j].aimHeight = totalHeight/25
				SetupPointStructure(segment[i].point[j], segment[i].structureArea, segment[i].area)
				
				totalCost = totalCost + abs(segment[i].point[j].diffHeight)
				areaCost = areaCost + (pointExtraAreaCostDepth > abs(segment[i].point[j].diffHeight) and abs(segment[i].point[j].diffHeight) or pointExtraAreaCostDepth)
				if not segment[i].area[segment[i].point[j].x] then
					segment[i].area[segment[i].point[j].x] = {}
				end
			end
		elseif terraform_type == 5 then
			for j = 1, segment[i].points do
				if not segment[i].area[segment[i].point[j].x] then
					segment[i].area[segment[i].point[j].x] = {}
				end
				segment[i].point[j].aimHeight = GetGroundOrigHeightOverride(segment[i].point[j].x, segment[i].point[j].z)
				SetupPointStructure(segment[i].point[j], segment[i].structureArea, segment[i].area)
				
				totalCost = totalCost + abs(segment[i].point[j].diffHeight)
				areaCost = areaCost + (pointExtraAreaCostDepth > abs(segment[i].point[j].diffHeight) and abs(segment[i].point[j].diffHeight) or pointExtraAreaCostDepth)
			end
		elseif terraform_type == 6 then
			for j = 1, segment[i].points do
				if not segment[i].area[segment[i].point[j].x] then
					segment[i].area[segment[i].point[j].x] = {}
				end
				segment[i].point[j].aimHeight = currHeight + bumpyFunc(segment[i].point[j].x,segment[i].point[j].z,volumeSelection)
				SetupPointStructure(segment[i].point[j], segment[i].structureArea, segment[i].area)
				
				totalCost = totalCost + abs(segment[i].point[j].diffHeight)
				areaCost = areaCost + (pointExtraAreaCostDepth > abs(segment[i].point[j].diffHeight) and abs(segment[i].point[j].diffHeight) or pointExtraAreaCostDepth)
			end
		end
		
		-- Perimeter Cost
		local pyramidCostEstimate = 0
		
		for j = 1, segment[i].points do
			local x = segment[i].point[j].x
			local z = segment[i].point[j].z
			
			if segment[i].area[x] and segment[i].area[x][z] then
				local edgeCount = 0
				
				if (not segment[i].area[x+8]) or (not segment[i].area[x+8][z]) then
					edgeCount = edgeCount + 1
				end
				if (not segment[i].area[x-8]) or (not segment[i].area[x-8][z]) then
					edgeCount = edgeCount + 1
				end
				if (not segment[i].area[x][z+8]) then
					edgeCount = edgeCount + 1
				end
				if (not segment[i].area[x][z-8]) then
					edgeCount = edgeCount + 1
				end
				
				if perimeterEdgeCost[edgeCount] > 0 then
					perimeterCost = perimeterCost + perimeterEdgeCost[edgeCount]*(pointExtraPerimeterCostDepth > abs(segment[i].point[j].diffHeight) and abs(segment[i].point[j].diffHeight) or pointExtraPerimeterCostDepth)
				end
				
				if edgeCount > 0 then
					local height = abs(segment[i].point[j].diffHeight)
					if height > 30 then
						pyramidCostEstimate = pyramidCostEstimate + ((height - height%maxHeightDifference)*(floor(height/maxHeightDifference)-1)*0.5 + floor(height/maxHeightDifference)*(height%maxHeightDifference))*volumeCost
					end
				end
			end
		end
		
		if totalCost ~= 0 then
			local baseCost = areaCost*pointExtraAreaCost + perimeterCost*pointExtraPerimeterCost + baseTerraunitCost
			totalCost = totalCost*volumeCost + baseCost
			
			if ECHO_DETAILED_COST_ESTIMATE then
				Spring.Echo("Total Cost", totalCost, "Area Cost", areaCost*pointExtraAreaCost, "Perimeter Cost", perimeterCost*pointExtraPerimeterCost)
			end
			local pos = segment[i].position
			local terraunitX, teamY, terraunitZ = GetTerraunitLeashedSpot(team, pos.x, pos.z, unitsX, unitsZ)
			
			local id = spCreateUnit(terraunitDefID, terraunitX, teamY or 0, terraunitZ, 0, team, true)
			if not id then
				-- TODO: notify user? SendToUnsynced("terra_failed_unitlimit", team, terraunitX, terraunitZ) -> Script.LuaUI.something -> Spring.MarkerAddPoint
			else
				spSetUnitHealth(id, 0.01)
				setupTerraunit(id, team, terraunitX, false, terraunitZ)
				spSetUnitRulesParam(id, "terraformType", terraform_type)
			
				blocks = blocks + 1
				block[blocks] = id
				
				terraformUnitCount = terraformUnitCount + 1
				terraformOrder[terraformOrders].indexes = terraformOrder[terraformOrders].indexes + 1

				terraformUnit[id] = {
					positionAnchor = pos,
					position = {x = terraunitX, z = terraunitZ},
					progress = 0,
					lastUpdate = 0,
					totalSpent = 0,
					volCostSpent = 0,
					baseCostSpent = 0,
					zeroProgressCost = 0,
					cost = totalCost,
					baseCost = baseCost,
					totalCost = totalCost,
					pyramidCostEstimate = pyramidCostEstimate,
					pyramidUpLimit = (volumeSelection == 1 and terraform_type == 2 and (absTerraformHeight + pyramidLimitExtra)),
					pyramidDownLimit = (volumeSelection == 2 and terraform_type == 2 and (absTerraformHeight + pyramidLimitExtra)),
					point = segment[i].point,
					points = segment[i].points,
					area = segment[i].area,
					border = segment[i].border,
					smooth = false,
					intercepts = 0,
					intercept = {},
					interceptMap = {},
					decayTime = frame + terraformDecayFrames,
					allyTeam = unitAllyTeam,
					team = team,
					order = terraformOrders,
					orderIndex = terraformOrder[terraformOrders].indexes,
					fullyInitialised = false,
					lastProgress = 0,
					lastHealth = 0,
					disableForceCompletion = disableForceCompletion,
					noDecay = noDecay,
				}
				InitialiseNearbyEnemy(id)
				
				terraformUnitTable[terraformUnitCount] = id
				terraformOrder[terraformOrders].index[terraformOrder[terraformOrders].indexes] = terraformUnitCount
				
				SetTooltip(id, 0, pyramidCostEstimate + totalCost)
			end
		end
		
	end
	
	AddFallbackCommand(team, commandTag, blocks, block, commandX, commandZ)
end

local function TerraformArea(terraform_type, mPoint, mPoints, terraformHeight, unit, units, team, volumeSelection, shift, commandX, commandZ, commandTag, disableForceCompletion, noDecay)
	local border = {left = mapWidth, right = 0, top = mapHeight, bottom = 0} -- border for the entire area
	
	--** Initial constructor processing **
	local unitsX, unitsZ = GetUnitAveragePosition(unit, units)
	if not unitsX then
		unitsX, unitsZ = commandX, commandZ
	end
	
	--** Convert Mouse Points to a Closed Loop on a Grid **
	-- close the mouse points loop
	mPoints = mPoints + 1
	mPoint[mPoints] = mPoint[1]
	
	-- points interpolated from mouse points
	local point = {}
	local points = 1
	
	-- snap mouse to grid
	mPoint[1].x = floor(mPoint[1].x/16)*16
	mPoint[1].z = floor(mPoint[1].z/16)*16
	point[1] = mPoint[1]
	updateBorderWithPoint(border, point[points].x, point[points].z)
	
	for i = 2, mPoints, 1 do
		-- snap mouse to grid
		mPoint[i].x = floor(mPoint[i].x/16)*16
		mPoint[i].z = floor(mPoint[i].z/16)*16
		
		local diffX = mPoint[i].x - mPoint[i-1].x
		local diffZ = mPoint[i].z - mPoint[i-1].z
		local a_diffX = abs(diffX)
		local a_diffZ = abs(diffZ)
			
		-- do not add another points of the same coordinates
		if a_diffX <= 16 and a_diffZ <= 16 then
			points = points + 1
			point[points] = {x = mPoint[i].x, z = mPoint[i].z}
			updateBorderWithPoint(border, point[points].x, point[points].z)
		else
			-- interpolate between far apart points to prevent loop holes.
			if a_diffX > a_diffZ then
				local m = diffZ/diffX
				local sign = diffX/a_diffX
				for j = 0, a_diffX, 16 do
					points = points + 1
					point[points] = {x = mPoint[i].x - j*sign, z = floor((mPoint[i].z - j*m*sign)/16)*16}
					updateBorderWithPoint(border, point[points].x, point[points].z)
				end
			else
				local m = diffX/diffZ
				local sign = diffZ/a_diffZ
				for j = 0, a_diffZ, 16 do
					points = points + 1
					point[points] = {x = floor((mPoint[i].x - j*m*sign)/16)*16, z = mPoint[i].z - j*sign}
					updateBorderWithPoint(border, point[points].x, point[points].z)
				end
			end
		end
		
		if border.right-border.left > maxAreaSize or border.bottom-border.top > maxAreaSize then
			-- cancel command if the area is too big, anti-slowdown
			return false
		end
	end
	
	--** Compute which points are on the inside of the Loop **
	-- Uses Floodfill, a faster algorithm is possible?
	
	local area = {}
	
	-- 2D array
	for i = border.left-16,border.right+16,16 do
		area[i] = {}
	end
	
	-- set loop edge points to 2. 2 cannot be flooded
	for i = 1, points do
		area[point[i].x][point[i].z] = 2
	end
	
	-- set all other array points to 1. 1 is vunerable
	for i = border.left,border.right,16 do
		for j = border.top,border.bottom,16 do
			if area[i][j] ~= 2 then
				area[i][j] = 1
			end
		end
	end
	
	-- set the points on the border of the array to -1. -1 is the 'flood'
	for i = border.left,border.right,16 do
		if area[i][border.top] ~= 2 then
			area[i][border.top] = -1
		end
		if area[i][border.bottom] ~= 2 then
			area[i][border.bottom] = -1
		end
	end
	for i = border.top,border.bottom,16 do
		if area[border.left][i] ~= 2 then
			area[border.left][i] = -1
		end
		if area[border.right][i] ~= 2 then
			area[border.right][i] = -1
		end
	end
	
	-- floodfill algorithm turning 1s into -1s. -1s turn to false
	local continue = true
	while continue do
		continue = false
		for i = border.left,border.right,16 do
			for j = border.top,border.bottom,16 do
				if area[i][j] == -1 then
					if area[i+16][j] == 1 then
						area[i+16][j] = -1
						continue = true
					end
					if area[i-16][j]  == 1 then
						area[i-16][j]  = -1
						continue = true
					end
					if area[i][j+16] == 1 then
						area[i][j+16] = -1
						continue = true
					end
					if area[i][j-16] == 1 then
						area[i][j-16] = -1
						continue = true
					end
					area[i][j] = false
				end
			end
		end
	end
	
	--** Break the area into segments to be individually terraformed **
	
	border.right = border.right + 16
	border.bottom = border.bottom + 16
	
	local width = (border.right-border.left)/ceil((border.right-border.left)/areaSegMaxSize)
	local height = (border.bottom-border.top)/ceil((border.bottom-border.top)/areaSegMaxSize)
	-- width and height are the witdh and height of segments. They must be squished to all be the same size
	
	local segment = {}
	
	local wCount = ceil((border.right-border.left)/areaSegMaxSize) - 1
	local hCount = ceil((border.bottom-border.top)/areaSegMaxSize) - 1
	-- w/hCount is the number of segments that fit into the width/height
	local addX = 0
	-- addX and addZ prevent overlap
	local n = 1 -- segment count
	for i = 0, wCount do
		local addZ = 0
		for j = 0, hCount do
			-- i and j step through possible segments based on splitting the rectangular area into rectangles
			segment[n] = {}
			segment[n].grid = {x = i, z = j}
			segment[n].point = {}
			segment[n].area = {}
			segment[n].border = {left = mapWidth, right = 0, top = mapHeight, bottom = 0}
			local totalX = 0
			local totalZ = 0
			-- totalX/Z is used to find the average position of the segment
			local m = 1 -- number of points in the segment
			for lx = border.left + floor(width * i/8)*8 + addX, border.left + floor(width * (i+1)/8)*8, 16 do
				for lz = border.top + floor(height * j/8)*8 + addZ, border.top + floor(height * (j+1)/8)*8, 16 do
					-- lx/lz steps though all 16x16 points
					if area[floor(lx/16)*16][floor(lz/16)*16] then
						--Spring.MarkerAddLine(floor(lx/16)*16-2,0,floor(lz/16)*16-2, floor(lx/16)*16+2,0,floor(lz/16)*16+2)
						--Spring.MarkerAddLine(floor(lx/16)*16-2,0,floor(lz/16)*16+2, floor(lx/16)*16+2,0,floor(lz/16)*16-2)
						
						-- fill in the top, left and middle
						for x = lx, lx+8, 8 do
							for z = lz, lz+8, 8 do
								local currHeight = spGetGroundHeight(x, z)
								if checkPointCreation(terraform_type, volumeSelection, currHeight, terraformHeight,GetGroundOrigHeightOverride(x, z), x, z) then
									segment[n].point[m] = {x = x, z = z, orHeight = currHeight, prevHeight = currHeight}
									m = m + 1
									totalX = totalX + x
									totalZ = totalZ + z
									updateBorderWithPoint(segment[n].border, x, z)
								end
							end
						end
						
						local right = not area[floor(lx/16)*16+16][floor(lz/16)*16]
						local bottom = not area[floor(lx/16)*16][floor(lz/16)*16+16]
						
						-- fill in bottom right if it is missing
						if right and bottom then
							local currHeight = spGetGroundHeight(lx+16, lz+16)
							if checkPointCreation(terraform_type, volumeSelection, currHeight, terraformHeight,GetGroundOrigHeightOverride(lx+16, lz+16), lx+16, lz+16) then
								segment[n].point[m] = {x = lx+16, z = lz+16, orHeight = currHeight, prevHeight = currHeight}
								m = m + 1
								totalX = totalX + lx+16
								totalZ = totalZ + lz+16
								updateBorderWithPoint(segment[n].border, lx+16, lz+16)
							end
						end
							
						if right then
							for z = lz, lz+8, 8 do
								local currHeight = spGetGroundHeight(lx+16, z)
								if checkPointCreation(terraform_type, volumeSelection, currHeight, terraformHeight,GetGroundOrigHeightOverride(lx+16, z), lx+16, z) then
									segment[n].point[m] = {x = lx+16, z = z, orHeight = currHeight, prevHeight = currHeight}
									m = m + 1
									totalX = totalX + lx+16
									totalZ = totalZ + z
									updateBorderWithPoint(segment[n].border, lx+16, z)
								end
							end
						end
						
						if bottom then
							for x = lx, lx+8, 8 do
								local currHeight = spGetGroundHeight(x, lz+16)
								if checkPointCreation(terraform_type, volumeSelection, currHeight, terraformHeight,GetGroundOrigHeightOverride(x, lz+16), x, lz+16) then
									segment[n].point[m] = {x = x, z = lz+16, orHeight = currHeight, prevHeight = currHeight}
									m = m + 1
									totalX = totalX + x
									totalZ = totalZ + lz+16
									updateBorderWithPoint(segment[n].border, x, lz+16)
								end
							end
						end
						
					end
				end
				
			end
			addZ = 8
			-- if there are no points in the segment the segment is discarded
			if m ~= 1 then
				segment[n].points = m - 1
				segment[n].position = {x = totalX/(m-1), z = totalZ/(m-1)}
				n = n + 1
			end
		end
		addX = 8
	end
	
	--** Detect potentially overlapping buildings**
	
	local localStructure = {}
	local localStructureCount = 0
	
	for i = 1, structureCount do
		local s = structure[structureTable[i]]
		if (border.left < s.maxx and
			border.right > s.minx and
			border.top < s.maxz and
			border.bottom > s.minz) then
				
			localStructureCount = localStructureCount + 1
			localStructure[localStructureCount] = i
		end
	end
	
	--** Creates terraform building and assigns each one segment data **
	
	local block = {}
	local blocks = 0
	
	terraformOrders = terraformOrders + 1
	terraformOrder[terraformOrders] = {border = border, index = {}, indexes = 0}

	local frame = spGetGameFrame()
	
	local unitIdGrid = {}
	local aveX = 0
	local aveZ = 0
	
	for i = 1,n-1 do
		-- detect overlapping buildings
		segment[i].structure = {}
		segment[i].structureCount = 0
		segment[i].structureArea = {}
		
		for j = 1, localStructureCount do
			local s = structure[structureTable[localStructure[j]]]
			if (segment[i].border.left < s.maxx and
				segment[i].border.right > s.minx and
				segment[i].border.top < s.maxz and
				segment[i].border.bottom > s.minz) then
				
				segment[i].structureCount = segment[i].structureCount + 1
				segment[i].structure[segment[i].structureCount] = {id = s}
				
				s.checkAtDeath = true
				
				for lx = s.minx, s.maxx, 8 do
					if not segment[i].structureArea[lx] then
						segment[i].structureArea[lx] = {}
					end
					for lz = s.minz,s.maxz, 8 do
						segment[i].structureArea[lx][lz] = (segment[i].structureArea[lx][lz] or 0) + 1
					end
				end
				
			end
		end
		
		--calculate cost of terraform
		local totalCost = 0
		local areaCost = 0
		local perimeterCost = 0
		local absTerraformHeight = abs(terraformHeight)
		
		if terraform_type == 1 then
			for j = 1, segment[i].points do
				if not segment[i].area[segment[i].point[j].x] then
					segment[i].area[segment[i].point[j].x] = {}
				end
				segment[i].point[j].aimHeight = terraformHeight
				SetupPointStructure(segment[i].point[j], segment[i].structureArea, segment[i].area)
				
				totalCost = totalCost + abs(segment[i].point[j].diffHeight)
				areaCost = areaCost + (pointExtraAreaCostDepth > abs(segment[i].point[j].diffHeight) and abs(segment[i].point[j].diffHeight) or pointExtraAreaCostDepth)
			end
		elseif terraform_type == 2 then
			for j = 1, segment[i].points do
				if not segment[i].area[segment[i].point[j].x] then
					segment[i].area[segment[i].point[j].x] = {}
				end
				segment[i].point[j].aimHeight = terraformHeight + segment[i].point[j].orHeight
				SetupPointStructure(segment[i].point[j], segment[i].structureArea, segment[i].area)
				
				totalCost = totalCost + abs(segment[i].point[j].diffHeight)
				areaCost = areaCost + (pointExtraAreaCostDepth > abs(segment[i].point[j].diffHeight) and abs(segment[i].point[j].diffHeight) or pointExtraAreaCostDepth)
			end
		elseif terraform_type == 3 then
			for j = 1, segment[i].points do
				local totalHeight = 0
				for lx = -16, 16,8 do
					for lz = -16, 16,8 do
						totalHeight = totalHeight + spGetGroundHeight(segment[i].point[j].x+lx, segment[i].point[j].z+lz)
					end
				end
				if not segment[i].area[segment[i].point[j].x] then
					segment[i].area[segment[i].point[j].x] = {}
				end
				segment[i].point[j].aimHeight = totalHeight/25
				SetupPointStructure(segment[i].point[j], segment[i].structureArea, segment[i].area)
				
				totalCost = totalCost + abs(segment[i].point[j].diffHeight)
				areaCost = areaCost + (pointExtraAreaCostDepth > abs(segment[i].point[j].diffHeight) and abs(segment[i].point[j].diffHeight) or pointExtraAreaCostDepth)
			end
		elseif terraform_type == 5 then
			for j = 1, segment[i].points do
				if not segment[i].area[segment[i].point[j].x] then
					segment[i].area[segment[i].point[j].x] = {}
				end
				segment[i].point[j].aimHeight = GetGroundOrigHeightOverride(segment[i].point[j].x, segment[i].point[j].z)
				SetupPointStructure(segment[i].point[j], segment[i].structureArea, segment[i].area)
				
				totalCost = totalCost + abs(segment[i].point[j].diffHeight)
				areaCost = areaCost + (pointExtraAreaCostDepth > abs(segment[i].point[j].diffHeight) and abs(segment[i].point[j].diffHeight) or pointExtraAreaCostDepth)
			end
		elseif terraform_type == 6 then
			for j = 1, segment[i].points do
				if not segment[i].area[segment[i].point[j].x] then
					segment[i].area[segment[i].point[j].x] = {}
				end
				segment[i].point[j].aimHeight = currHeight + bumpyFunc(segment[i].point[j].x,segment[i].point[j].z,volumeSelection)
				SetupPointStructure(segment[i].point[j], segment[i].structureArea, segment[i].area)
				
				totalCost = totalCost + abs(segment[i].point[j].diffHeight)
				areaCost = areaCost + (pointExtraAreaCostDepth > abs(segment[i].point[j].diffHeight) and abs(segment[i].point[j].diffHeight) or pointExtraAreaCostDepth)
			end
			
		end
		
		-- Perimeter Cost
		local pyramidCostEstimate = 0 -- just for UI
		
		for j = 1, segment[i].points do
			local x = segment[i].point[j].x
			local z = segment[i].point[j].z
			
			if segment[i].area[x] and segment[i].area[x][z] then
				
				local edgeCount = 0
				
				if (not segment[i].area[x+8]) or (not segment[i].area[x+8][z]) then
					edgeCount = edgeCount + 1
				end
				if (not segment[i].area[x-8]) or (not segment[i].area[x-8][z]) then
					edgeCount = edgeCount + 1
				end
				if (not segment[i].area[x][z+8]) then
					edgeCount = edgeCount + 1
				end
				if (not segment[i].area[x][z-8]) then
					edgeCount = edgeCount + 1
				end
				
				if perimeterEdgeCost[edgeCount] > 0 then
					perimeterCost = perimeterCost + perimeterEdgeCost[edgeCount]*(pointExtraPerimeterCostDepth > abs(segment[i].point[j].diffHeight) and abs(segment[i].point[j].diffHeight) or pointExtraPerimeterCostDepth)
				end
				
				if edgeCount > 0 then
					local diffHeight = abs(segment[i].point[j].diffHeight)
					if diffHeight > 30 then
						pyramidCostEstimate = pyramidCostEstimate + ((diffHeight - diffHeight%maxHeightDifference)*(floor(diffHeight/maxHeightDifference)-1)*0.5 + floor(diffHeight/maxHeightDifference)*(diffHeight%maxHeightDifference))*volumeCost
					end
				end
			end
		end
		
		if totalCost ~= 0 then
			local baseCost = areaCost*pointExtraAreaCost + perimeterCost*pointExtraPerimeterCost + baseTerraunitCost
			totalCost = totalCost*volumeCost + baseCost
			
			if ECHO_DETAILED_COST_ESTIMATE then
				Spring.Echo("Total Cost", totalCost, "Area Cost", areaCost*pointExtraAreaCost, "Perimeter Cost", perimeterCost*pointExtraPerimeterCost)
			end
			local pos = segment[i].position
			local terraunitX, teamY, terraunitZ = GetTerraunitLeashedSpot(team, pos.x, pos.z, unitsX, unitsZ)
			
			local id = spCreateUnit(terraunitDefID, terraunitX, teamY or 0, terraunitZ, 0, team, true)
			
			if id then
				spSetUnitHealth(id, 0.01)
				unitIdGrid[segment[i].grid.x] = unitIdGrid[segment[i].grid.x] or {}
				unitIdGrid[segment[i].grid.x][segment[i].grid.z] = id
				
				aveX = aveX + segment[i].position.x
				aveZ = aveZ + segment[i].position.z
				
				setupTerraunit(id, team, terraunitX, false, terraunitZ)
				spSetUnitRulesParam(id, "terraformType", terraform_type)
			
				blocks = blocks + 1
				block[blocks] = id
				
				terraformUnitCount = terraformUnitCount + 1
				terraformOrder[terraformOrders].indexes = terraformOrder[terraformOrders].indexes + 1

				terraformUnit[id] = {
					positionAnchor = pos,
					position = {x = terraunitX, z = terraunitZ},
					progress = 0,
					lastUpdate = 0,
					totalSpent = 0,
					volCostSpent = 0,
					baseCostSpent = 0,
					zeroProgressCost = 0,
					cost = totalCost,
					baseCost = baseCost,
					totalCost = totalCost,
					pyramidCostEstimate = pyramidCostEstimate,
					pyramidUpLimit = (volumeSelection == 1 and terraform_type == 2 and (absTerraformHeight + pyramidLimitExtra)),
					pyramidDownLimit = (volumeSelection == 2 and terraform_type == 2 and (absTerraformHeight + pyramidLimitExtra)),
					point = segment[i].point,
					points = segment[i].points,
					area = segment[i].area,
					border = segment[i].border,
					smooth = false,
					intercepts = 0,
					intercept = {},
					interceptMap = {},
					decayTime = frame + terraformDecayFrames,
					allyTeam = unitAllyTeam,
					team = team,
					order = terraformOrders,
					orderIndex = terraformOrder[terraformOrders].indexes,
					fullyInitialised = false,
					lastProgress = 0,
					lastHealth = 0,
					disableForceCompletion = disableForceCompletion,
					noDecay = noDecay,
				}
				InitialiseNearbyEnemy(id)

				terraformUnitTable[terraformUnitCount] = id
				terraformOrder[terraformOrders].index[terraformOrder[terraformOrders].indexes] = terraformUnitCount
				
				SetTooltip(id, 0, pyramidCostEstimate + totalCost)
			end
		end
		
	end
	
	--** Give repair order for each block to all selected units **
	if terraformOrder[terraformOrders].indexes == 0 then
		return
	end
	
	aveX = aveX/terraformOrder[terraformOrders].indexes
	aveZ = aveZ/terraformOrder[terraformOrders].indexes
	
	local orderList = {data = {}, count = 0}
	
	if unitsX < unitsZ - aveZ + aveX then -- left or top
		if unitsX < -unitsZ + aveZ + aveX then -- left
			local zig = 0
			if unitsZ > aveZ then  -- 4th octant
				zig = 1
			end
			for gx = 0, wCount do
				for gz = 0 + hCount*zig, hCount*(1-zig), 1-zig*2 do
					if unitIdGrid[gx] and unitIdGrid[gx][gz] then
						orderList.count = orderList.count + 1
						orderList.data[orderList.count] = unitIdGrid[gx][gz]
					end
				end
				zig = 1 - zig
			end
		else -- top
			local zig = 0
			if unitsX > aveX then  -- 2nd octant
				zig = 1
			end
			for gz = hCount, 0, -1 do
				for gx = 0 + wCount*zig, wCount*(1-zig), 1-zig*2 do
					if unitIdGrid[gx] and unitIdGrid[gx][gz] then
						orderList.count = orderList.count + 1
						orderList.data[orderList.count] = unitIdGrid[gx][gz]
					end
				end
				zig = 1 - zig
			end
		end
	else -- bottom or right
		if unitsX < -unitsZ + aveZ + aveX then -- bottom
			local zig = 0
			if unitsX > aveX then  -- 7th octant
				zig = 1
			end
			for gz = 0, hCount do
				for gx = 0 + wCount*zig, wCount*(1-zig), 1-zig*2 do
					if unitIdGrid[gx] and unitIdGrid[gx][gz] then
						orderList.count = orderList.count + 1
						orderList.data[orderList.count] = unitIdGrid[gx][gz]
					end
				end
				zig = 1 - zig
			end
		else -- right
			local zig = 0
			if unitsZ > aveZ then  -- 1st octant
				zig = 1
			end
			for gx = wCount, 0, -1  do
				for gz = 0 + hCount*zig, hCount*(1-zig), 1-zig*2 do
					if unitIdGrid[gx] and unitIdGrid[gx][gz] then
						orderList.count = orderList.count + 1
						orderList.data[orderList.count] = unitIdGrid[gx][gz]
					end
				end
				zig = 1 - zig
			end
		end
	end
	
	if orderList.count == 0 then
		return
	end
	
	AddFallbackCommand(team, commandTag, orderList.count, orderList.data, commandX, commandZ)
end

--------------------------------------------------------------------------------
-- Recieve Terraform command from UI widget
--------------------------------------------------------------------------------

function gadget:AllowCommand_GetWantedCommand()
	return wantedCommands
end

function gadget:AllowCommand_GetWantedUnitDefID()
	return true
end

function gadget:AllowCommand(unitID, unitDefID, teamID, cmdID, cmdParams, cmdOptions)
	-- Don't allow non-constructors to queue terraform fallback.
	if fallbackableCommands[cmdID] and not terraformUnitDefIDs[unitDefID] then
		return false
	end

	if (cmdID == CMD_TERRAFORM_INTERNAL) then
		if GG.terraformRequiresUnlock and not GG.terraformUnlocked[teamID] then
			return false
		end
		
		local terraform_type = cmdParams[1]
		local commandX = cmdParams[3]
		local commandZ = cmdParams[4]
		local commandTag = cmdParams[5]
		local loop = cmdParams[6]
		local terraformHeight = cmdParams[7]
		local pointCount = cmdParams[8]
		local constructorCount = cmdParams[9]
		local volumeSelection = cmdParams[10]
		
		if (not pointCount) or (not maxCommandPoints) or (not maxCommandUnits) or (pointCount > maxCommandPoints) or (constructorCount > maxCommandUnits) then
			return
		end
		
		--level or raise or smooth or restore or bumpify
		if terraform_type == 1 or terraform_type == 2 or terraform_type == 3 or terraform_type == 5 then --or terraform_type == 6 then
			local point = {}
			local unit = {}
			local i = 11
			for j = 1, pointCount do
				point[j] = {x = cmdParams[i], z = cmdParams[i+1]}
				i = i + 2
			end
			for j = 1, constructorCount do
				unit[j] = cmdParams[i]
				i = i + 1
			end
			
			if loop == 0 then
				TerraformWall(terraform_type, point, pointCount, terraformHeight, unit, constructorCount, teamID, volumeSelection, cmdOptions.shift, commandX, commandZ, commandTag)
			else
				TerraformArea(terraform_type, point, pointCount, terraformHeight, unit, constructorCount, teamID, volumeSelection, cmdOptions.shift, commandX, commandZ, commandTag)
			end
			
			return false

		elseif terraform_type == 4 then --ramp
		
			local point = {}
			local unit = {}
			local i = 11
			for j = 1, pointCount do
				point[j] = {x = cmdParams[i], y = cmdParams[i+1],z = cmdParams[i+2]}
				i = i + 3
			end
			for j = 1, constructorCount do
				unit[j] = cmdParams[i]
				i = i + 1
			end
			
			TerraformRamp(point[1].x,point[1].y,point[1].z,point[2].x,point[2].y,point[2].z,terraformHeight*2,unit, constructorCount,teamID, volumeSelection, cmdOptions.shift, commandX, commandZ, commandTag)
		
			return false
		end
	end
	return true -- allowed
end

--------------------------------------------------------------------------------
-- Sudden Death Mode
--------------------------------------------------------------------------------

function GG.Terraform_RaiseWater(raiseAmount)
	Spring.SetGameRulesParam("waterlevel", (Spring.GetGameRulesParam("waterlevel") or 0) + raiseAmount)
	
	for i = 1, structureCount do
		local s = structure[structureTable[i]]
		s.h = s.h - raiseAmount
	end
	
	for i = 1, terraformUnitCount do
		local id = terraformUnitTable[i]
		for j = 1, terraformUnit[id].points do
			local point = terraformUnit[id].point[j]
			point.orHeight = point.orHeight - raiseAmount
			point.aimHeight = point.aimHeight - raiseAmount
		end
	end
	--[[ move commands looks as though it will be messy
	
	local allUnits = Spring.GetAllUnits()
	local allUnitsCount = #allUnits
	for i = 1, allUnitsCount do
		if spValidUnitID(allUnits[i]) then
			local x,y,z = spGetUnitPosition(allUnits[i])
			spSetUnitPosition(x,y-raiseAmount,z)
			local commands = spGetUnitCommands(allUnits[i], -1)
			local commandsCount = #commands
			for j = 1, commandsCount do
			
			end
		end
	end
	--]]
	Spring.AdjustHeightMap(0, 0, mapWidth, mapHeight, -raiseAmount)
	Spring.AdjustOriginalHeightMap(0, 0, mapWidth, mapHeight, -raiseAmount)
	
	Spring.SetGameRulesParam("waterLevelModifier", raiseAmount)
	
	local features = Spring.GetAllFeatures()
	for i = 1, #features do
		local featureID = features[i]
		local fx, fy, fz = Spring.GetFeaturePosition(featureID)
		if featureID and fy then
			Spring.SetFeaturePosition(featureID, fx, fy - raiseAmount, fz, true)
		end
	end
end

--------------------------------------------------------------------------------
-- Handle terraunit
--------------------------------------------------------------------------------

local function deregisterTerraformUnit(id,terraformIndex,origin)
	if not terraformUnit[id] then
		Spring.Log(gadget:GetInfo().name, LOG.ERROR, "Terraform:")
		Spring.Log(gadget:GetInfo().name, LOG.ERROR, "Attempted to remove nil terraform ID")
		Spring.Log(gadget:GetInfo().name, LOG.ERROR, "Error Tpye " .. origin)
		Spring.Log(gadget:GetInfo().name, LOG.ERROR, "Tell Google Frog")
		return
	end
	
	if ECHO_COST then
		local cost = terraformUnit[id].totalSpent
		Spring.Echo("TerraCost", cost)
		Spring.Utilities.UnitEcho(id, cost)
	end
	
	--Removed Intercept Check
	--if not terraformUnit[id].intercepts then
	--    Spring.Echo("Terraform:")
	--    Spring.Echo("Attempted to index terraformUnit with wrong id")
	--    Spring.Echo("Tell Google Frog")
	--    return
	--end
	----Spring.MarkerAddPoint(terraformUnit[id].position.x,0,terraformUnit[id].position.z,"Spent " .. terraformUnit[id].totalSpent)
	--
	-- remove from intercepts tables
	--for j = 1, terraformUnit[id].intercepts do -- CRASH ON THIS LINE -- not for a while though
	--    local oid = terraformUnit[id].intercept[j].id
	--    local oindex = terraformUnit[id].intercept[j].index
	--    if oindex < terraformUnit[oid].intercepts then
	--        terraformUnit[terraformUnit[oid].intercept[terraformUnit[oid].intercepts].id].intercept[terraformUnit[oid].intercept[terraformUnit[oid].intercepts].index].index = oindex
	--        terraformUnit[oid].intercept[oindex] = terraformUnit[oid].intercept[terraformUnit[oid].intercepts]
	--    end
	--    terraformUnit[oid].intercept[terraformUnit[oid].intercepts] = nil
	--    terraformUnit[oid].intercepts = terraformUnit[oid].intercepts - 1
	--    terraformUnit[oid].interceptMap[id] = nil
	--end
	
	--Spring.MarkerAddPoint(terraformUnit[id].position.x, 0, terraformUnit[id].position.z, "Spent: " .. terraformUnit[id].totalSpent)
	
	-- remove from order table
	local to = terraformOrder[terraformUnit[id].order]
	if terraformUnit[id].orderIndex ~= to.indexes then
		to.index[terraformUnit[id].orderIndex] = to.index[to.indexes]
		terraformUnit[terraformUnitTable[to.index[to.indexes]]].orderIndex = terraformUnit[id].orderIndex
	end
	to.indexes = to.indexes - 1
	
	-- remove order table if it is now emty
	if to.indexes < 1 then
		if terraformOrders ~= terraformUnit[id].order then
			terraformOrder[terraformUnit[id].order] = terraformOrder[terraformOrders]
			for i = 1, terraformOrder[terraformOrders].indexes do
				terraformUnit[terraformUnitTable[terraformOrder[terraformOrders].index[i]]].order = terraformUnit[id].order
			end
		end
		terraformOrders = terraformOrders - 1
	end
	
	-- remove from terraform table
	terraformUnit[id] = nil
	if terraformIndex ~= terraformUnitCount then
		terraformUnitTable[terraformIndex] = terraformUnitTable[terraformUnitCount]
		local t = terraformUnit[terraformUnitTable[terraformUnitCount]]
		terraformOrder[t.order].index[t.orderIndex] = terraformIndex
	end
	terraformUnitCount = terraformUnitCount - 1
end

local function updateTerraformEdgePoints(id)
	for i = 1, terraformUnit[id].points do
		local point = terraformUnit[id].point[i]
		
		if point.structure then
			point.edges = nil
		else
			local x = point.x
			local z = point.z

			local area = terraformUnit[id].area
			local edges = 0
			local edge = {}
			
			local spots = {top = false, bot = false, left = false, right = false}
			
			if (not area[x-8]) or (not area[x-8][z]) then
				spots.left = true
			end
			if (not area[x+8]) or (not area[x+8][z]) then
				spots.right = true
			end
			if not area[x][z-8] then
				spots.top = true
			end
			if not area[x][z+8] then
				spots.bot = true
			end
			
			if spots.left then
				edges = edges + 1
				edge[edges] = {x = x-8, z = z, checkX = -8, checkZ = nil}
				if spots.top then
					edges = edges + 1
					edge[edges] = {x = x-8, z = z-8, checkX = -8, checkZ = -8}
				end
				if spots.bot then
					edges = edges + 1
					edge[edges] = {x = x-8, z = z+8, checkX = -8, checkZ = 8}
				end
			end
			
			if spots.right then
				edges = edges + 1
				edge[edges] = {x = x+8, z = z, checkX = 8, checkZ = nil}
				if spots.top then
					edges = edges + 1
					edge[edges] = {x = x+8, z = z-8, checkX = 8, checkZ = -8}
				end
				if spots.bot then
					edges = edges + 1
					edge[edges] = {x = x+8, z = z+8, checkX = 8, checkZ = 8}
				end
			end
			
			if spots.top then
				edges = edges + 1
				edge[edges] = {x = x, z = z-8, checkX = nil, checkZ = -8}
			end
			
			if spots.bot then
				edges = edges + 1
				edge[edges] = {x = x, z = z+8, checkX = nil, checkZ = 8}
			end
			
			if edges ~= 0 then
				point.edges = edges
				point.edge = edge
			else
				point.edges = nil
			end
		end
	end
end

local function CheckThickness(x, z, area)
	-- This function returns whether the terraform point has sufficient nearby points
	-- for the terraform to not be considered too thin.

	if x%16 == 8 then
		if z%16 == 8 then
			local north = area[x] and (area[x][z-16] ~= nil)
			local northEast = area[x+16] and (area[x+16][z-16] ~= nil)
			local east = area[x+16] and (area[x+16][z] ~= nil)
			if north and northEast and east then
				return true
			end
			local southEast = area[x+16] and (area[x+16][z+16] ~= nil)
			if northEast and east and southEast then
				return true
			end
			local south = area[x] and (area[x][z+16] ~= nil)
			if east and southEast and south then
				return true
			end
			local southWest = area[x-16] and (area[x-16][z+16] ~= nil)
			if southEast and south and southWest then
				return true
			end
			local west = area[x-16] and (area[x-16][z] ~= nil)
			if south and southWest and west then
				return true
			end
			local northWest = area[x-16] and (area[x-16][z-16] ~= nil)
			if southWest and west and northWest then
				return true
			end
			if west and northWest and north then
				return true
			end
			if northWest and north and northEast then
				return true
			end
		else
			return (area[x] and (area[x][z-8] ~= nil)) or (area[x] and (area[x][z+8] ~= nil))
		end
	elseif z%16 == 8 then
		return (area[x-8] and (area[x-8][z] ~= nil)) or (area[x+8] and (area[x+8][z] ~= nil))
	else
		if area[x-8] and (area[x-8][z-8] ~= nil) then
			return true
		end
		if area[x-8] and (area[x-8][z+8] ~= nil) then
			return true
		end
		if area[x+8] and (area[x+8][z-8] ~= nil) then
			return true
		end
		if area[x+8] and (area[x+8][z+8] ~= nil) then
			return true
		end
	end
	return false
end

local function updateTerraformCost(id)
	local terra = terraformUnit[id]

	local checkAreaRemoved = true
	local areaRemoved = false
	while checkAreaRemoved do
		checkAreaRemoved = false
		for i = 1, terra.points do
			local point = terra.point[i]
			if not point.structure then
				local x = point.x
				local z = point.z
				
				if not CheckThickness(x, z, terra.area) then
					if terra.area[x] and terra.area[x][z] then
						terra.area[x][z] = nil
					end
					point.structure = true
					areaRemoved = true
					checkAreaRemoved = true
				end
			end
		end
	end
	
	if areaRemoved then
		updateTerraformEdgePoints(id)
	end
	
	local volume = 0
	for i = 1, terra.points do
		local point = terra.point[i]
		local x = point.x
		local z = point.z
		
		local height = spGetGroundHeight(x,z)
		point.orHeight = height
		if point.structure then
			point.diffHeight = 0
		else
			point.diffHeight = point.aimHeight - height
		end
		volume = volume + abs(point.diffHeight)
	end
	
	if volume < 0.0001 then
		-- Destroying the terraform here would enable structure-detecting maphax.
		volume = 0.0001
		terra.toRemove = true
	end
	
	terra.zeroProgressCost = terra.volCostSpent
	terra.cost = terra.volCostSpent + volume*volumeCost
	terra.totalCost = terra.cost + terra.baseCost
	
	terra.progress = ((terra.baseCostSpent or terra.baseCost) + terra.volCostSpent) / terra.totalCost
	terra.lastProgress = terra.progress
	terra.lastHealth = terra.progress*terraUnitHP
	
	EchoDebug(id, "updateTerraformCost", "volume", volume, "terra.volCostSpent", terra.volCostSpent, "extra", volume*volumeCost)
	spSetUnitHealth(id, {
		health = terra.lastHealth,
		build  = terra.lastProgress*terraBuildMult
	})
	
	EchoDebug(id, "Update Cost", terra.cost, terra.totalCost)
	
	return true
end


local function checkTerraformIntercepts(id)
	for i = 1, terraformOrders do
		--Spring.MarkerAddLine(terraformOrder[i].border.left,0,terraformOrder[i].border.top,terraformOrder[i].border.right,0,terraformOrder[i].border.top)
		--Spring.MarkerAddLine(terraformOrder[i].border.left,0,terraformOrder[i].border.bottom,terraformOrder[i].border.right,0,terraformOrder[i].border.bottom)
		--Spring.MarkerAddLine(terraformOrder[i].border.left,0,terraformOrder[i].border.top,terraformOrder[i].border.left,0,terraformOrder[i].border.bottom)
		--Spring.MarkerAddLine(terraformOrder[i].border.right,0,terraformOrder[i].border.top,terraformOrder[i].border.right,0,terraformOrder[i].border.bottom)
		if (terraformOrder[i].border.left <= terraformOrder[terraformUnit[id].order].border.right and
			terraformOrder[i].border.right >= terraformOrder[terraformUnit[id].order].border.left and
			terraformOrder[i].border.top <= terraformOrder[terraformUnit[id].order].border.bottom and
			terraformOrder[i].border.bottom >= terraformOrder[terraformUnit[id].order].border.top) then
			
			for j = 1, terraformOrder[i].indexes do
				local oid = terraformUnitTable[terraformOrder[i].index[j]]
				if oid ~= id and not terraformUnit[id].interceptMap[oid] and terraformUnit[oid].fullyInitialised then
					if (terraformUnit[id].border.left <= terraformUnit[oid].border.right and
						terraformUnit[id].border.right >= terraformUnit[oid].border.left and
						terraformUnit[id].border.top <= terraformUnit[oid].border.bottom and
						terraformUnit[id].border.bottom >= terraformUnit[oid].border.top) then
						
						terraformUnit[oid].intercepts = terraformUnit[oid].intercepts + 1
						terraformUnit[id].intercepts = terraformUnit[id].intercepts + 1
					
						terraformUnit[oid].intercept[terraformUnit[oid].intercepts] = {index = terraformUnit[id].intercepts, id = id}
						terraformUnit[id].intercept[terraformUnit[id].intercepts] = {index = terraformUnit[oid].intercepts, id = oid}
						
						terraformUnit[oid].interceptMap[id] = true
						terraformUnit[id].interceptMap[oid] = true
					end
				end
			end
		end
	end

end

local function updateTerraformBorder(id,x,z) -- updates border for edge point x,z
	
	local change = false
	
	if x < terraformUnit[id].border.left then
		terraformUnit[id].border.left = x
		change = true
	end
	if x > terraformUnit[id].border.right then
		terraformUnit[id].border.right = x
		change = true
	end
	if z < terraformUnit[id].border.top then
		terraformUnit[id].border.top = z
		change = true
	end
	if z > terraformUnit[id].border.bottom then
		terraformUnit[id].border.bottom = z
		change = true
	end
	
	if change then
		local border = terraformOrder[terraformUnit[id].order].border
		if x < border.left then
			border.left = x
		end
		if x > border.right then
			border.right = x
		end
		if z < border.top then
			border.top = z
		end
		if z > border.bottom then
			border.bottom = z
		end
		
		checkTerraformIntercepts(id)
	end

end

local function finishInitialisingTerraformUnit(id)
	--checkTerraformIntercepts(id) --Removed Intercept Check
	updateTerraformEdgePoints(id)
	EchoDebug(id, "init update cost")
	updateTerraformCost(id)
	
	--Spring.MarkerAddPoint(terraformUnit[id].position.x,0,terraformUnit[id].position.z,"Base " .. terraformUnit[id].baseCost)
	--Spring.MarkerAddPoint(terraformUnit[id].position.x,0,terraformUnit[id].position.z,"Cost " .. terraformUnit[id].cost)
	--Spring.MarkerAddPoint(terraformUnit[id].position.x,0,terraformUnit[id].position.z,"Points " .. terraformUnit[id].points)
	terraformUnit[id].fullyInitialised = true
end

local function addSteepnessMarker(team, x, z)
	local n = spGetGameFrame()
	if steepnessMarkers.inner.frame ~= n then
		steepnessMarkers.inner = {count = 0, data = {}, frame = n}
	end
	Spring.Echo(steepnessMarkers.inner.frame)
	steepnessMarkers.inner.count = steepnessMarkers.inner.count+1
	steepnessMarkers.inner.data[steepnessMarkers.inner.count] = {team = team, x = x, z = z}
end

local function GetHeightDiffLocal(xDiff, zDiff, innerEdgeDist)
	if innerEdgeDist then
		if xDiff == 0 then
			return innerEdgeDist + (zDiff - 8)*maxHeightDifference/8
		end
		if zDiff == 0 then
			return innerEdgeDist + (xDiff - 8)*maxHeightDifference/8
		end
		return SQRT_2*innerEdgeDist + sqrt((xDiff - 8)^2 + (zDiff - 8)^2)*maxHeightDifference/8
	end
	if xDiff == 0 then
		return zDiff*maxHeightDifference/8
	end
	if zDiff == 0 then
		return xDiff*maxHeightDifference/8
	end
	return sqrt(xDiff^2 + zDiff^2)*maxHeightDifference/8
end

local function updateTerraform(health, id, arrayIndex, costDiff)
	local terra = terraformUnit[id]
	
	if terra.toRemove and terra.totalSpent > 0.1 then
		-- Removing terraform too early enables structure-detecting maphax.
		deregisterTerraformUnit(id,arrayIndex,2)
		spDestroyUnit(id, false, true)
		return 0
	end
	
	if terra.baseCostSpent then
		EchoDebug(id, "baseCostSpent", terra.baseCostSpent, terra.baseCost)
		if costDiff < terra.baseCost - terra.baseCostSpent then
			if terra.baseCostSpent < noBuildBaseCost then
				terra.baseCostSpent = terra.baseCostSpent + costDiff
				
				local newBuild = terra.baseCostSpent/terra.totalCost
				EchoDebug(id, "SetHealth Base", newBuild*terraUnitHP, newBuild)
				spSetUnitHealth(id, {
					health = newBuild*terraUnitHP,
					build  = newBuild*terraBuildMult
				})
				terra.lastHealth = newBuild*terraUnitHP
				terra.lastProgress = newBuild
				return 1
			end
			
			terra.baseCostSpent = terra.baseCostSpent + costDiff*baseSpendProp
			costDiff = costDiff*(1 - baseSpendProp)
		else
			costDiff = costDiff - (terra.baseCost - terra.baseCostSpent)
			terra.baseCostSpent = false
		end
	end
	
	local x, z
	for i = 1, terra.points do
		x, z = terra.point[i].x, terra.point[i].z
		-- For some reason the heightDiff check always fails for points on the map edge, so just ignore them.
		if x > 0 and x < mapWidth and z > 0 and z < mapHeight then
			local heightDiff = terra.point[i].prevHeight - spGetGroundHeight(x, z)
			if heightDiff ~= 0 then
				EchoDebug(id, "heightDiff ~= 0 update cost", terra.point[i].x, terra.point[i].z, "prev", terra.point[i].prevHeight, "now", spGetGroundHeight(terra.point[i].x, terra.point[i].z))
				--for j = 1, terra.points do
				--	local heightDiff = terra.point[j].prevHeight - spGetGroundHeight(terra.point[j].x, terra.point[j].z)
				--	if heightDiff ~= 0 then
				--		Spring.MarkerAddPoint(terra.point[j].x, 0, terra.point[j].z)
				--	end
				--end
				updateTerraformCost(id)
				break
				-- There must be a nicer way to update costs, below is an unstable attempt.
				--local change = ((1-terra.progress)*terra.point[i].diffHeight + heightDiff)/((1-terra.progress)*terra.point[i].diffHeight)
				--Spring.Echo(change)
				--local costChange = (abs(change * terra.point[i].diffHeight) - abs(terra.point[i].diffHeight))*volumeCost
				--terra.point[i].diffHeight = change * terra.point[i].diffHeight
				--terra.point[i].orHeight = terra.point[i].aimHeight - terra.point[i].diffHeight
				--terraformUnit[id].cost = terraformUnit[id].cost + costChange
				--terraformUnit[id].totalCost = terraformUnit[id].totalCost + costChange
			end
		end
	end
	
	local newProgress = (terra.volCostSpent - terra.zeroProgressCost + costDiff) / (terra.cost - terra.zeroProgressCost)
	if newProgress> 1 then
		newProgress = 1
	end
	
	local pyramidVolumeChange = 0
	local extraPoint = {}
	local extraPoints = 0
	local extraPointArea = {}
	
	--[[
	for i = 1, terra.points do
		if terra.point[i].edges then
			for j = 1, terra.point[i].edges do
			
				local x = terra.point[i].edge[j].x
				local z = terra.point[i].edge[j].z
				
				Spring.MarkerAddLine(x-2,0,z-2, x+2,0,z+2)
				Spring.MarkerAddLine(x-2,0,z+2, x+2,0,z-2)
				
			end
		end
	end
	--]]
	
	--Spring.Echo(" === newProgress === ", newProgress)
	
	for i = 1, terra.points do
		if terra.point[i].edges then
			local newHeight = terra.point[i].orHeight+(terra.point[i].aimHeight-terra.point[i].orHeight)*newProgress
			local makingPyramid = terra.point[i].aimHeight - terra.point[i].orHeight > 0
			for j = 1, terra.point[i].edges do
				local thisEdge = terra.point[i].edge[j]
				x, z = thisEdge.x, thisEdge.z
			
				local groundHeight = spGetGroundHeight(x, z)
				local edgeHeight = groundHeight
				local overlap, overlapReplaces = false, false
				local overlapHeightDiff = 0
				if extraPointArea[x] and extraPointArea[x][z] then
					overlap = extraPointArea[x][z]
					if extraPoint[overlap].supportID then
						edgeHeight = extraPoint[overlap].orHeight + extraPoint[overlap].heightDiff
					else
						overlapReplaces = true
					end
					overlapHeightDiff = abs(extraPoint[overlap].heightDiff)
				end
				
				local maxDiff
				if makingPyramid then
					maxDiff = (thisEdge.checkX and thisEdge.checkZ and (SQRT_2*maxHeightDifference)) or maxHeightDifference
				else
					maxDiff = (thisEdge.checkX and thisEdge.checkZ and (SQRT_2*maxHeightDiffDownInner)) or maxHeightDiffDownInner
				end

				local heightSign = (makingPyramid and 1 or -1)
				local diffHeight = newHeight - edgeHeight
				if (diffHeight > maxDiff and makingPyramid) or (diffHeight < -maxDiff and not makingPyramid) then
					local index = extraPoints + 1
					if overlap then
						if (not overlapReplaces) and extraPoint[overlap].pyramid ~= makingPyramid then
							addSteepnessMarker(terra.team, terra.position.x,terra.position.z)
							deregisterTerraformUnit(id,arrayIndex,2)
							spDestroyUnit(id, false, true)
							return 0
						end
						index = overlap
					else
						extraPoints = extraPoints + 1
					end

					extraPoint[index] = {
						x = x,
						z = z,
						orHeight = groundHeight,
						heightDiff = newHeight - groundHeight - heightSign*maxDiff,
						supportX = terra.point[i].x,
						supportZ = terra.point[i].z,
						supportH = newHeight,
						supportID = i,
						checkX = thisEdge.checkX,
						checkZ = thisEdge.checkZ,
						pyramid = makingPyramid, -- pyramid = rising up, not pyramid = ditch
					}
					--updateTerraformBorder(id,x,z) --Removed Intercept Check
					
					if (not IsPositionTerraformable(x, z)) or
							(makingPyramid and terra.pyramidUpLimit and diffHeight > terra.pyramidUpLimit) or
							((not makingPyramid) and terra.pyramidDownLimit and diffHeight < -terra.pyramidDownLimit) then
						if terra.area[terra.point[i].x] and terra.area[terra.point[i].x][terra.point[i].z] then
							terra.area[terra.point[i].x][terra.point[i].z] = false
						end
						terra.point[i].diffHeight = 0.0001
						terra.point[i].structure = true
						return -1
					end
					
					pyramidVolumeChange = pyramidVolumeChange + abs(extraPoint[index].heightDiff) - overlapHeightDiff
					
					if not extraPointArea[x] then
						extraPointArea[x] = {}
					end
					extraPointArea[x][z] = index
				else
					-- Check for smooth edge around base of pyramid
					local parentGoal = terra.point[i].aimHeight
					local borderHeightDiff = false
					if makingPyramid then
						if groundHeight + maxEdgeHeightDiff < parentGoal then
							borderHeightDiff = min(maxEdgeHeightDiff, parentGoal - groundHeight + maxEdgeHeightDiff)
						end
					else
						if groundHeight - maxEdgeHeightDiff > parentGoal then
							borderHeightDiff = min(maxEdgeHeightDiff, groundHeight - maxEdgeHeightDiff - parentGoal)
						end
					end
					
					local lookX, lookZ = x + (thisEdge.checkX or 0), z + (thisEdge.checkZ or 0)
					if borderHeightDiff and not (terra.area[lookX] and terra.area[lookX][lookZ]) then
						local lookAheadHeight = spGetGroundHeight(lookX, lookZ)
						if (not (extraPointArea[x] and extraPointArea[x][z])) and
								((makingPyramid and groundHeight < lookAheadHeight + borderHeightDiff) or ((not makingPyramid) and groundHeight > lookAheadHeight - borderHeightDiff)) and
								IsPositionTerraformable(x, z) then
							
							extraPoints = extraPoints + 1
							extraPoint[extraPoints] = {
								x = x,
								z = z,
								orHeight = groundHeight,
								heightDiff = heightSign*borderHeightDiff + lookAheadHeight - groundHeight,
								pyramid = makingPyramid, -- pyramid = rising up, not pyramid = ditch
							}
							
							pyramidVolumeChange = pyramidVolumeChange + abs(extraPoint[extraPoints].heightDiff)
							
							if not extraPointArea[x] then
								extraPointArea[x] = {}
							end
							extraPointArea[x][z] = extraPoints
						end
					end
				end
			end
		end
	end
	
	do
	
	local i = 1
	local checkIndex
	local diffX, diffZ
	while i <= extraPoints do
		if extraPoint[i].supportID then
			local newHeight = extraPoint[i].supportH
			-- diamond pyramids
			--local maxHeightDifferenceLocal = (abs(extraPoint[i].x-extraPoint[i].supportX) + abs(extraPoint[i].z-extraPoint[i].supportZ))*maxHeightDifference/8+maxHeightDifference
			-- circular pyramids
			checkIndex = 0
			while checkIndex < 2 do
				if checkIndex == 0 and extraPoint[i].checkX then
					x = extraPoint[i].x + extraPoint[i].checkX
					z = extraPoint[i].z
					diffX, diffZ = extraPoint[i].checkX, 0
					checkIndex = 1
				elseif extraPoint[i].checkZ then
					x = extraPoint[i].x
					z = extraPoint[i].z + extraPoint[i].checkZ
					diffX, diffZ = 0, extraPoint[i].checkZ
					checkIndex = 2
				else
					break
				end
				
				--and not (extraPointArea[x] and extraPointArea[x][z])
				if not (terra.area[x] and terra.area[x][z]) then
					local groundHeight = spGetGroundHeight(x, z)
					local edgeHeight = groundHeight
					local overlap, overlapReplaces = false, false
					local overlapHeightDiff = 0
					if extraPointArea[x] and extraPointArea[x][z] then
						overlap = extraPointArea[x][z]
						if extraPoint[overlap].supportID then
							edgeHeight = extraPoint[overlap].orHeight + extraPoint[overlap].heightDiff
						else
							overlapReplaces = true
						end
						overlapHeightDiff = abs(extraPoint[overlap].heightDiff)
					end
					local maxHeightDifferenceLocal = GetHeightDiffLocal(abs(x - extraPoint[i].supportX), abs(z - extraPoint[i].supportZ), (not extraPoint[i].pyramid) and maxHeightDiffDownInner)

					local heightSign = (extraPoint[i].pyramid and 1 or -1)
					local diffHeight = newHeight - edgeHeight
					if (diffHeight > maxHeightDifferenceLocal and extraPoint[i].pyramid) or (diffHeight < -maxHeightDifferenceLocal and not extraPoint[i].pyramid) then
						local index = extraPoints + 1
						if overlap then
							if (not overlapReplaces) and extraPoint[overlap].pyramid ~= extraPoint[i].pyramid then
								addSteepnessMarker(terra.team, terra.position.x,terra.position.z)
								deregisterTerraformUnit(id,arrayIndex,2)
								spDestroyUnit(id, false, true)
								return 0
							end
							index = overlap
						else
							extraPoints = extraPoints + 1
						end
						extraPoint[index] = {
							x = x,
							z = z,
							orHeight = groundHeight,
							heightDiff = newHeight - groundHeight - heightSign*maxHeightDifferenceLocal,
							supportX = extraPoint[i].supportX,
							supportZ = extraPoint[i].supportZ,
							supportH = extraPoint[i].supportH,
							supportID = extraPoint[i].supportID,
							checkX =  extraPoint[i].checkX,
							checkZ =  extraPoint[i].checkZ,
							pyramid = extraPoint[i].pyramid, -- pyramid = rising up, not pyramid = ditch
						}
						--updateTerraformBorder(id,x,z) --Removed Intercept Check
						
						if not IsPositionTerraformable(x, z) or
								(extraPoint[i].pyramid and terra.pyramidUpLimit and diffHeight > terra.pyramidUpLimit) or
								((not extraPoint[i].pyramid) and terra.pyramidDownLimit and diffHeight < -terra.pyramidDownLimit) then
							if terra.area[extraPoint[index].supportX] and terra.area[extraPoint[index].supportX][extraPoint[index].supportZ] then
								terra.area[extraPoint[index].supportX][extraPoint[index].supportZ] = false
							end
							terra.point[extraPoint[i].supportID].diffHeight = 0.0001
							terra.point[extraPoint[i].supportID].structure = true
							return -1
						end
						
						pyramidVolumeChange = pyramidVolumeChange + abs(extraPoint[index].heightDiff) - overlapHeightDiff
						
						if not extraPointArea[x] then
							extraPointArea[x] = {}
						end
						extraPointArea[x][z] = index
					else
						-- Check for smooth edge around base of pyramid
						local parentGoal = extraPoint[i].orHeight + extraPoint[i].heightDiff
						local borderHeightDiff = false
						if extraPoint[i].pyramid then
							if groundHeight + maxEdgeHeightDiff < parentGoal then
								borderHeightDiff = min(maxEdgeHeightDiff, parentGoal - groundHeight + maxEdgeHeightDiff)
							end
						else
							if groundHeight - maxEdgeHeightDiff > parentGoal then
								borderHeightDiff = min(maxEdgeHeightDiff, groundHeight - maxEdgeHeightDiff - parentGoal)
							end
						end
						
						if borderHeightDiff and not (terra.area[x + diffX] and terra.area[x + diffX][z + diffZ]) then
							local lookAheadHeight = spGetGroundHeight(x + diffX, z + diffZ)
							if (not (extraPointArea[x] and extraPointArea[x][z])) and
									((extraPoint[i].pyramid and groundHeight < lookAheadHeight + borderHeightDiff) or ((not extraPoint[i].pyramid) and groundHeight > lookAheadHeight - borderHeightDiff)) and
									IsPositionTerraformable(x, z) then
								
								extraPoints = extraPoints + 1
								extraPoint[extraPoints] = {
									x = x,
									z = z,
									orHeight = groundHeight,
									heightDiff = heightSign*borderHeightDiff + lookAheadHeight - groundHeight,
									pyramid = extraPoint[i].pyramid, -- pyramid = rising up, not pyramid = ditch
								}
								
								pyramidVolumeChange = pyramidVolumeChange + abs(extraPoint[extraPoints].heightDiff)
								
								if not extraPointArea[x] then
									extraPointArea[x] = {}
								end
								extraPointArea[x][z] = extraPoints
							end
						end
					end
				end
			end
		end
		
		if extraPoints > 7000 then
			Spring.Log(gadget:GetInfo().name, LOG.WARNING, "spire wall break")
			break -- safty
		end
		i = i + 1
	end
	
	end -- End do
	
	-- Update costs and determine progress.
	terraformOperations = terraformOperations + extraPoints
	local pyramindCost = pyramidVolumeChange*volumeCost
	
	if IsDebug(unitID) then
		Spring.Echo("costDiff", costDiff)
	end
	
	local edgeTerraMult = 1
	if costDiff ~= 0 then
		if pyramindCost == 0 then
			terra.volCostSpent = terra.volCostSpent + costDiff
			terra.progress = ((terra.baseCostSpent or terra.baseCost) + terra.volCostSpent + costDiff) / terra.totalCost
		else
			local edgeSpendFactor = (terra.baseCostSpent and 0.38) or 1
			local edgeSpending = costDiff*edgeSpendFactor*(1 - costDiff/(costDiff + pyramindCost))
			
			if terra.volCostSpent + costDiff > terra.cost then
				local costRemaining = terra.cost - terra.volCostSpent
				edgeSpending = costDiff*(1 - costRemaining/(costRemaining + pyramindCost))
			end
			if edgeSpending > pyramindCost then
				edgeSpending = pyramindCost
			end
			
			EchoDebug(unitID, "volCostSpent", terra.volCostSpent, "cost", terra.cost, "totalCost", terra.totalCost, "pyramindCost", pyramindCost, "edgeSpending", edgeSpending)
			
			costDiff = costDiff - edgeSpending
			edgeTerraMult = edgeSpending/pyramindCost
			terra.volCostSpent = terra.volCostSpent + costDiff
			terra.progress = ((terra.baseCostSpent or terra.baseCost) + terra.volCostSpent) / terra.totalCost
		end
	end
	
	if edgeTerraMult > 1 then
		Spring.Log(gadget:GetInfo().name, LOG.ERROR, "Terraform:")
		Spring.Log(gadget:GetInfo().name, LOG.ERROR, "edgeTerraMult > 1 THIS IS VERY BAD")
		Spring.Log(gadget:GetInfo().name, LOG.ERROR, "Tell Google Frog")
	end
	
	--Spring.Echo("terra.progress", terra.progress)
	local terraformUpdateProgress = (terra.volCostSpent - terra.zeroProgressCost) / (terra.cost - terra.zeroProgressCost)
	if terraformUpdateProgress > 1 or terra.progress >= 1 then
		terraformUpdateProgress = 1
		edgeTerraMult = 1
		terra.progress = 1
	end
	--Spring.Echo("progress", terraformUpdateProgress, "edgeTerraMult", edgeTerraMult, "pyramindCost", pyramindCost)

	EchoDebug(id, "SetHealth", terra.progress*terraUnitHP, terra.progress)
	
	terra.lastHealth = terra.progress*terraUnitHP
	spSetUnitHealth(id, {
		health = terra.lastHealth,
		build  = terra.progress*terraBuildMult
	})
	terra.lastProgress = terra.progress

	-- Bug Safety
	for i = 1, extraPoints do
		if abs(extraPoint[i].orHeight + extraPoint[i].heightDiff*edgeTerraMult) > 3000 then
			Spring.Log(gadget:GetInfo().name, LOG.WARNING, "Terraform:")
			Spring.Log(gadget:GetInfo().name, LOG.WARNING, "Strange pyramid construction")
			Spring.Log(gadget:GetInfo().name, LOG.WARNING, "Destroying Terraform Unit")
			deregisterTerraformUnit(id,arrayIndex,2)
			spDestroyUnit(id, false, true)
			return 0
		end
	end
	
	local func = function()
		for i = 1, terra.points do
			local height = terra.point[i].orHeight+terra.point[i].diffHeight*terraformUpdateProgress
			spSetHeightMap(terra.point[i].x,terra.point[i].z, height)
			terra.point[i].prevHeight = height
		end
		for i = 1, extraPoints do
			spSetHeightMap(extraPoint[i].x,extraPoint[i].z,extraPoint[i].orHeight + extraPoint[i].heightDiff*edgeTerraMult)
		end
	end
	spSetHeightMapFunc(func)

	-- Draw the changes
	if USE_TERRAIN_TEXTURE_CHANGE then
		local drawX = {}
		local drawZ = {}
		local drawTex = {}
		local drawEdge = {}
		local count = 0
		
		for i = 1, terra.points do
			x = terra.point[i].x
			z = terra.point[i].z
			local freeLeft = not (terra.area[x-8] and terra.area[x-8][z]) and not (extraPointArea[x-8] and extraPointArea[x-8][z])
			local freeUp = not (terra.area[x] and terra.area[x][z-8]) and not (extraPointArea[x] and extraPointArea[x][z-8])
			local freeRight = not (terra.area[x+8] and terra.area[x+8][z]) and not (extraPointArea[x+8] and extraPointArea[x+8][z])
			local freeDown = not (terra.area[x] and terra.area[x][z+8]) and not (extraPointArea[x] and extraPointArea[x][z+8])
			
			count = count + 1
			drawX[count] = x
			drawZ[count] = z
			drawTex[count] = 1
			drawEdge[count] = ((freeRight or freeDown) and 1) or 0
			
			if freeLeft then
				count = count + 1
				drawX[count] = x  - 8
				drawZ[count] = z
				drawTex[count] = 1
				drawEdge[count] = 1
			end
			if freeUp then
				count = count + 1
				drawX[count] = x
				drawZ[count] = z - 8
				drawTex[count] = 1
				drawEdge[count] = 1
				if freeLeft then
					count = count + 1
					drawX[count] = x - 8
					drawZ[count] = z - 8
					drawTex[count] = 1
					drawEdge[count] = 1
				end
			end
		end
		
		for i = 1, extraPoints do
			local x = extraPoint[i].x
			local z = extraPoint[i].z
			local freeLeft = not (extraPointArea[x-8] and extraPointArea[x-8][z])
			local freeUp = not (terra.area[x] and terra.area[x][z-8]) and not (extraPointArea[x] and extraPointArea[x][z-8])

			count = count + 1
			drawX[count] = x
			drawZ[count] = z
			drawTex[count] = 2
			drawEdge[count] = 2
			
			if freeLeft then
				count = count + 1
				drawX[count] = x - 8
				drawZ[count] = z
				drawTex[count] = 2
				drawEdge[count] = 2
			end
			if freeUp then
				count = count + 1
				drawX[count] = x
				drawZ[count] = z - 8
				drawTex[count] = 2
				drawEdge[count] = 2
				if freeLeft then
					count = count + 1
					drawX[count] = x - 8
					drawZ[count] = z - 8
					drawTex[count] = 2
					drawEdge[count] = 2
				end
			end
		end
		
		for i = 1, count do
			local x = drawX[i] + 4
			local z = drawZ[i] + 4
			local edge = (drawEdge[i] == 1)
			local extraEdge = (drawEdge[i] == 2)
			
			-- edge exists because raised walls have passability at higher normal than uniform ramps
			local oHeight = GetGroundOrigHeightOverride(drawX[i], drawZ[i], 4, 4)
			local height = spGetGroundHeight(x, z)
			if abs(oHeight-height) < 1 then
				drawTex[i] = 0
			else
				local normal = select(2, Spring.GetGroundNormal(x,z))
				if (edge and normal > 0.82) or (normal > 0.892) then
					drawTex[i] = 1
				elseif ((edge or extraEdge) and normal > 0.455) or (normal > 0.585) then
					drawTex[i] = 2
				else
					drawTex[i] = 3
				end
			end
		end
		
		GG.Terrain_Texture_changeBlockList(drawX, drawZ, drawTex)
	end
	
	--Removed Intercept Check
	--if terraformUnit[id].intercepts ~= 0 then
	--    local i = 1
	--    while i <= terra.intercepts  do
	--        local test = updateTerraformCost(terra.intercept[i].id)
	--        if test then
	--            i = i + 1
	--        end
	--    end
	--end
	EchoDebug(id, "terra.points", terra.points, "newProgress", newProgress)
	
	if terra.progress >= 1 then
		deregisterTerraformUnit(id,arrayIndex,2)
		spDestroyUnit(id, false, true)
		return 0
	end
	
	return 1
end

local function DoTerraformUpdate(n, forceCompletion)
	local i = 1
	while i <= terraformUnitCount do
		local id = terraformUnitTable[i]
		if IsDebug(id) then
			-- EchoDebug(id, "Check", Spring.GetUnitHealth(id))
		end
		if (spValidUnitID(id)) then
			local force = (forceCompletion and not terraformUnit[id].disableForceCompletion)
			
			local health = spGetUnitHealth(id)
			if health - terraformUnit[id].lastHealth == 0 then
				if (not forceCompletion) and (n % decayCheckFrequency == 0 and (not terraformUnit[id].noDecay) and terraformUnit[id].decayTime < n) then
					EchoUnit(id)
					EchoDebug(id, "Decay", id)
					deregisterTerraformUnit(id,i,3)
					spDestroyUnit(id, false, true)
				else
					i = i + 1
					if (n - terraformUnit[id].lastUpdate >= updatePeriod) then
						CheckNearbyEnemy(id)
						terraformUnit[id].lastUpdate = n
					end
				end
			else
				if not terraformUnit[id].fullyInitialised then
					finishInitialisingTerraformUnit(id,i)
				end
				
				if force or (n - terraformUnit[id].lastUpdate >= updatePeriod) then
					CheckNearbyEnemy(id)
					local costDiff = health - terraformUnit[id].lastHealth
					if force then
						costDiff = costDiff + 100000 -- enough?
					end
					EchoUnit(id)
					EchoDebug(id, "============== " .. id .. " ==============")
					terraformUnit[id].totalSpent = terraformUnit[id].totalSpent + costDiff
					EchoDebug(id, "Spent", terraformUnit[id].totalSpent, costDiff, terraformUnit[id].lastHealth)
					SetTooltip(id, terraformUnit[id].totalSpent, terraformUnit[id].pyramidCostEstimate + terraformUnit[id].totalCost)
					
					if GG.Awards and GG.Awards.AddAwardPoints then
						GG.Awards.AddAwardPoints('terra', terraformUnit[id].team, costDiff)
					end
					
					local attempts = 1
					local updateVar = updateTerraform(health,id,i,costDiff)
					EchoDebug(id, "updateVar", updateVar)
					while updateVar == -1 and attempts < 10 do
						if updateTerraformCost(id) then
							EchoDebug(id, "updateVar == -1 update cost")
							updateTerraformEdgePoints(id)
							updateVar = updateTerraform(health,id,i,costDiff)
							attempts = attempts + 1
						else
							updateVar = 0
						end
						EchoDebug(id, "updateVar while", updateVar)
					end
					--Spring.Echo("attempts", attempts)
					
					if updateVar == 1 then
						terraformUnit[id].lastUpdate = n
						i = i + 1
					end
				else
					i = i + 1
				end
			end
		else
			-- remove if the unit is no longer valid
			deregisterTerraformUnit(id,i,4)
		end
	end
end

function gadget:GameFrame(n)
	if n == 0 and wantForceCompleteFrameZero then
		DoTerraformUpdate(n, true)
	end

	if n >= nextUpdateCheck then
		updatePeriod = math.max(MIN_UPDATE_PERIOD, min(MAX_UPDATE_PERIOD, terraformOperations/60))
		--Spring.Echo("Terraform operations", terraformOperations, updatePeriod)
		terraformOperations = 0
		nextUpdateCheck = n + updatePeriod
	end
	
	DoTerraformUpdate(n, freeTerraform)
	
	--check constrcutors that are repairing terraform blocks
	if constructors ~= 0 then
		if n % checkInterval == 0 then
			-- only check 1 con per cycle
			currentCon = currentCon + 1
			if currentCon > constructors then
				currentCon = 1
			end
			
			local unitID = constructorTable[currentCon]
			local cQueue = spGetUnitCommands(unitID, -1)
			if cQueue then
				local teamID = spGetUnitTeam(unitID)
				local ncq = #cQueue
				for i = 1, ncq do
					local cmd = cQueue[i]
					if fallbackableCommands[cmd.id] then
						if fallbackCommands[teamID] and cmd.params and cmd.params[4] then
							local terraCmd = fallbackCommands[teamID][cmd.params[4]]
							if terraCmd and terraCmd.terraunitList then
								local terraUnitList = terraCmd.terraunitList
								for j = 1, #terraUnitList do
									if terraformUnit[terraUnitList[j]] then
										terraformUnit[terraUnitList[j]].decayTime = n + terraformDecayFrames
									end
								end
							end
						end
					elseif cmd.id == CMD_REPAIR then
						if #cmd.params == 1 then
							-- target unit command
							if terraformUnit[cmd.params[1]] then
								terraformUnit[cmd.params[1]].decayTime = n + terraformDecayFrames
							end
							
							-- bring terraunit towards con
							if i == 1 and spValidUnitID(cmd.params[1]) and terraformUnit[cmd.params[1] ] then
								local cx, _, cz = spGetUnitPosition(unitID)
								if cx and teamID then

									local tpos = terraformUnit[cmd.params[1] ].positionAnchor
									local x, y, z = GetTerraunitLeashedSpot(teamID, tpos.x, tpos.z, cx, cz)
									terraformUnit[cmd.params[1] ].position = {x = x, z = z}
									spSetUnitPosition(cmd.params[1], x, y , z)
									--Spring.MoveCtrl.Enable(cmd.params[1])
									--Spring.MoveCtrl.SetPosition(cmd.params[1], x, y , z)
									--Spring.MoveCtrl.Disable(cmd.params[1])
								end
							end
							
						elseif #cmd.params == 4 then -- there is a command with 5 params that I do not want
							-- area command
							local radSQ = cmd.params[4]^2
							local cX, _, cZ = cmd.params[1],cmd.params[2],cmd.params[3]
							if constructor[unitID] and constructor[unitID].allyTeam then
								local allyTeam = constructor[unitID].allyTeam
								for j = 1, terraformUnitCount do
									local terra = terraformUnit[terraformUnitTable[j]]
									if terra.allyTeam == allyTeam then
										local disSQ = (terra.position.x - cX)^2 + (terra.position.z - cZ)^2
										if disSQ < radSQ then
											--Spring.MarkerAddPoint(terra.position.x,0,terra.position.z,"saved " .. cX)
											terra.decayTime = n + terraformDecayFrames
										end
									end
								end
							end
						end
					end
				end
			end
		end
	end
	
	--check structures for terrain deformation
	local struc = structureCheckFrame[n % structureCheckLoopFrames]
	if struc then
		local i = 1
		while i <= struc.count do
			local unit = structure[struc.unit[i]]
			if unit then
				local height = spGetGroundHeight(unit.x, unit.z)
				if height ~= unit.h then
					spLevelHeightMap(unit.minx,unit.minz,unit.maxx,unit.maxz,unit.h)
				end
			end
			i = i + 1
		end
	end
end

function gadget:CommandFallback(unitID, unitDefID, teamID, cmdID, cmdParams, cmdOptions)
	if not fallbackableCommands[cmdID] then
		return false
	end
	if not fallbackCommands[teamID] then
		return false
	end
	if not (cmdParams and cmdParams[4]) then
		return false
	end
	local command = fallbackCommands[teamID][cmdParams[4]]
	if not command then
		return false
	end
	
	if not terraformUnitDefIDs[unitDefID] then
		return false, true
	end
	
	local ux,_,uz = spGetUnitPosition(unitID)
	
	local closestID
	local closestDistanceSq
	for i = 1, command.terraunits do
		local terraID = command.terraunitList[i]
		if (Spring.ValidUnitID(terraID) and Spring.GetUnitDefID(terraID) == terraunitDefID) then
			local tx,_,tz = spGetUnitPosition(terraID)
			local distanceSq = (tx-ux)*(tx-ux) + (tz-uz)*(tz-uz)
			if (not closestDistanceSq) or (distanceSq < closestDistanceSq) then
				closestID = terraID
				closestDistanceSq = distanceSq
			end
		end
	end

	if closestID then
		REPAIR_ORDER_PARAMS[4] = closestID
		spGiveOrderToUnit(unitID, CMD_INSERT, REPAIR_ORDER_PARAMS, CMD_OPT_ALT)
		return true, false
	end

	fallbackCommands[teamID][cmdParams[4]] = nil
	return false
end

function gadget:UnitPreDamaged(unitID, unitDefID, unitTeam, damage, paralyzer, weaponID, attackerID, attackerDefID, attackerTeam)
	if unitDefID == terraunitDefID then
		return 0 -- terraunit starts on 0 HP. If a unit is damaged and has 0 HP it dies
	end
	return damage
end

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Weapon smoothing that takes structures into account

local function DoSmoothDirectly(
		x, z, sx, sz, smoothradius, origHeight, groundHeight,
		maxSmooth, smoothradiusSQ, FalloffFunc, smoothExponent, movestructures)
	local structI = movestructures and {}
	local structJ = movestructures and {}
	local IsPositionTerraformable = GG.Terraform.IsPositionTerraformable
	
	for i = sx - smoothradius, sx + smoothradius,8 do
		for j = sz - smoothradius, sz + smoothradius,8 do
			if IsPositionTerraformable(i, j) then
				local disSQ = (i - x)^2 + (j - z)^2
				if disSQ <= smoothradiusSQ then
					if smoothExponent then
						local newHeight = (groundHeight - spGetGroundHeight(i,j)) * maxSmooth * FalloffFunc(disSQ, smoothradiusSQ, smoothExponent)
						spAddHeightMap(i, j, newHeight)
					else
						local newHeight = (groundHeight - spGetGroundHeight(i,j)) * maxSmooth * (1 - disSQ/smoothradiusSQ)^1.5
						spAddHeightMap(i, j, newHeight)
					end
				end
			elseif structI then
				structI[#structI + 1] = i
				structJ[#structJ + 1] = j
			end
		end
	end
	
	if not movestructures then
		return
	end
	
	local structHeight = {}
	local structTested = {}
	for s = 1, #structI do
		local i = structI[s]
		local j = structJ[s]
		local height = 0
		local structCount = 0
		local k = 1
		while structureAreaMap[k] and structureAreaMap[k][i] and structureAreaMap[k][i][j] do
			local unitID = structureAreaMap[k][i][j]
			if not structTested[unitID] then
				local structData = structure[unitID]
				local disSQ = (x - structData.x)^2 + (z - structData.z)^2
				if disSQ <= smoothradiusSQ
						and IsPositionTerraformable(structData.minx, structData.minz, true) and IsPositionTerraformable(structData.maxx, structData.minz, true)
						and IsPositionTerraformable(structData.minx, structData.maxz, true) and IsPositionTerraformable(structData.maxx, structData.maxz, true) then
					local gh = spGetGroundHeight(i,j)
					structData.h = (groundHeight - gh) * maxSmooth * movestructures * FalloffFunc(disSQ, smoothradiusSQ, smoothExponent or 1) + gh
					structHeight[unitID] = structData.h
					-- Causes structures to become non-blocking.
					--local unitDefID = Spring.GetUnitDefID(unitID)
					--if unitDefID then
					--	local moveHeight = (UnitDefs[unitDefID].floatOnWater and math.max(structData.h, 0)) or structData.h
					--	Spring.MoveCtrl.Enable(unitID)
					--	Spring.MoveCtrl.SetPosition(unitID, structData.x, moveHeight, structData.z)
					--	Spring.MoveCtrl.Disable(unitID)
					--end
				end
				structTested[unitID] = true
			end
			if structHeight[unitID] then
				height = height + structHeight[unitID]
				structCount = structCount + 1
			end
			k = k + 1
		end
		if structCount > 0 then
			height = height/structCount
			spSetHeightMap(i, j, height)
		end
	end
end

--------------------------------------------------------------------------------
-- Structure Handling
--------------------------------------------------------------------------------

local function DeregisterStructure(unitID)
	if not structure[unitID] then
		return
	end
	if structure[unitID].checkAtDeath then
		for i = 1, terraformOrders do
			if (structure[unitID].minx < terraformOrder[i].border.right and
				structure[unitID].maxx > terraformOrder[i].border.left and
				structure[unitID].minz < terraformOrder[i].border.bottom and
				structure[unitID].maxz> terraformOrder[i].border.top) then
				
				for j = 1, terraformOrder[i].indexes do
					local oid = terraformUnitTable[terraformOrder[i].index[j]]
					if (structure[unitID].minx < terraformUnit[oid].border.right and
						structure[unitID].maxx > terraformUnit[oid].border.left and
						structure[unitID].minz < terraformUnit[oid].border.bottom and
						structure[unitID].maxz > terraformUnit[oid].border.top) then

						local recalc = false
						for k = 1, terraformUnit[oid].points do
							if structure[unitID].area[terraformUnit[oid].point[k].x] then
								if structure[unitID].area[terraformUnit[oid].point[k].x][terraformUnit[oid].point[k].z] then
									if terraformUnit[oid].point[k].structure == true then
										terraformUnit[oid].point[k].structure = false
									else
										terraformUnit[oid].point[k].structure = terraformUnit[oid].point[k].structure - 1
										if terraformUnit[oid].point[k].structure <= 0 then
											terraformUnit[oid].point[k].structure = false
										end
									end
									terraformUnit[oid].area[terraformUnit[oid].point[k].x][terraformUnit[oid].point[k].z] = true
									recalc = true
								end
							end
							if terraformUnit[oid].point[k].structure == true then
								terraformUnit[oid].point[k].structure = false
								terraformUnit[oid].area[terraformUnit[oid].point[k].x][terraformUnit[oid].point[k].z] = true
								recalc = true
							end
						end
						
						if recalc then
							updateTerraformEdgePoints(oid)
							EchoDebug(id, "DeregisterStructure update cost")
							updateTerraformCost(oid)
						end
					end
				end
			end
		end
	end
	
	for i = structure[unitID].minx, structure[unitID].maxx, 8 do
		for j = structure[unitID].minz, structure[unitID].maxz, 8 do
			RemoveStructure(unitID, i, j)
		end
	end
	
	local f = structureCheckFrame[structure[unitID].frame]
	if f.count ~= structure[unitID].frameIndex then
		structureCheckFrame[structure[unitID].frame].unit[structure[unitID].frameIndex] = structureCheckFrame[structure[unitID].frame].unit[f.count]
	end
	if structureCheckFrame[structure[unitID].frame].count == 1 then
		structureCheckFrame[structure[unitID].frame] = nil
	else
		structureCheckFrame[structure[unitID].frame].count = structureCheckFrame[structure[unitID].frame].count - 1
	end
		
	if structure[unitID].index ~= structureCount then
		structureTable[structure[unitID].index] = structureTable[structureCount]
		structure[structureTable[structureCount]].index = structure[unitID].index
	end
	structureCount = structureCount - 1
	structure[unitID] = nil
end

local function RegisterStructure(unitID, ud)
	local ux, uy, uz = spGetUnitPosition(unitID)
	ux = floor((ux+4)/8)*8
	uz = floor((uz+4)/8)*8
	local face = spGetUnitBuildFacing(unitID)
	local xsize = ud.xsize*4
	local ysize = (ud.zsize or ud.ysize)*4
	
	structureCount = structureCount + 1
	
	if ((face == 0) or(face == 2)) then
		structure[unitID] = { x = ux, z = uz , h = spGetGroundHeight(ux, uz), def = ud,
		minx = ux-xsize, minz = uz-ysize, maxx = ux+xsize, maxz = uz+ysize, area = {}, index = structureCount}
	else
		structure[unitID] = { x = ux, z = uz , h = spGetGroundHeight(ux, uz), def = ud,
		minx = ux-ysize, minz = uz-xsize, maxx = ux+ysize, maxz = uz+xsize, area = {}, index = structureCount}
	end
	
	if structure[unitID].minx == 0 then
		structure[unitID].minx = -8
	end
	if structure[unitID].minz == 0 then
		structure[unitID].minz = -8
	end
	if structure[unitID].maxx == mapWidth then
		structure[unitID].maxx = mapWidth + 8
	end
	if structure[unitID].maxz == mapHeight then
		structure[unitID].maxz = mapHeight + 8
	end
	
	for i = structure[unitID].minx, structure[unitID].maxx, 8 do
		structure[unitID].area[i] = {}
		for j = structure[unitID].minz, structure[unitID].maxz, 8 do
			structure[unitID].area[i][j] = true
			AddStructure(unitID, i, j)
		end
	end
	
	structureTable[structureCount] = unitID
	
	-- slow update for terrain checking
	if not structureCheckFrame[currentCheckFrame] then
		structureCheckFrame[currentCheckFrame] = {count = 0, unit = {}}
	end
	structureCheckFrame[currentCheckFrame].count = structureCheckFrame[currentCheckFrame].count + 1
	structureCheckFrame[currentCheckFrame].unit[structureCheckFrame[currentCheckFrame].count] = unitID
	structure[unitID].frame = currentCheckFrame
	structure[unitID].frameIndex = structureCheckFrame[currentCheckFrame].count
	
	currentCheckFrame = currentCheckFrame + 1
	if currentCheckFrame > structureCheckLoopFrames then
		currentCheckFrame = 0
	end
	
	-- check if the building is on terraform
	for i = 1, terraformOrders do
		if (structure[unitID].minx < terraformOrder[i].border.right and
			structure[unitID].maxx > terraformOrder[i].border.left and
			structure[unitID].minz < terraformOrder[i].border.bottom and
			structure[unitID].maxz> terraformOrder[i].border.top) then
			
			for j = 1, terraformOrder[i].indexes  do
				local oid = terraformUnitTable[terraformOrder[i].index[j]]

				if (structure[unitID].minx < terraformUnit[oid].border.right and
					structure[unitID].maxx > terraformUnit[oid].border.left and
					structure[unitID].minz < terraformUnit[oid].border.bottom and
					structure[unitID].maxz > terraformUnit[oid].border.top) then
					
					structure[unitID].checkAtDeath = true
					
					local recalc = false
					local area = terraformUnit[oid].area
					for k = 1, terraformUnit[oid].points do
						local point = terraformUnit[oid].point[k]
						local x, z = point.x, point.z
						if structure[unitID].area[x] and structure[unitID].area[x][z] then
							terraformUnit[oid].point[k].diffHeight = 0.0001
							if terraformUnit[oid].point[k].structure ~= true then
								terraformUnit[oid].point[k].structure = (terraformUnit[oid].point[k].structure or 0) + 1
							end
							if area[x] and area[x][z] then
								area[x][z] = nil
							end
							recalc = true
						end
					end
					
					if recalc then
						EchoDebug(id, "UnitCreated update cost")
						updateTerraformCost(oid)
						updateTerraformEdgePoints(oid)
					end
				end
			end
		end
	end
end

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

function gadget:UnitGiven(unitID, unitDefID, teamID, oldTeamID)
	if unitID and unitDefID and teamID and terraunitDefID == unitDefID then
		SetInivisbleToEnemy(unitID, teamID)
	end
end

function gadget:UnitDestroyed(unitID, unitDefID)
	if constructor[unitID] then
		local index = constructor[unitID].index
		if index ~= constructors then
			constructorTable[index] = constructorTable[constructors]
		end
		constructorTable[constructors] = nil
		constructors = constructors - 1
		constructor[unitID]    = nil
		
		if constructors ~= 0 then
			checkInterval = ceil(checkLoopFrames/constructors)
			if checkInterval <= 1 then
				checkLoopFrames = checkLoopFrames * 2
			end
			checkInterval = ceil(checkLoopFrames/constructors)
		end
	end

	if structure[unitID] then
		DeregisterStructure(unitID)
	end
end

function gadget:UnitCreated(unitID, unitDefID, teamID)
	if spGetUnitIsDead(unitID) then
		return
	end
	
	local ud = UnitDefs[unitDefID]
	-- add terraform commands to builders
	if terraformUnitDefIDs[unitDefID] and not(GG.terraformRequiresUnlock and not GG.terraformUnlocked[teamID]) then
		for _, cmdDesc in ipairs(cmdDescsArray) do
			spInsertUnitCmdDesc(unitID, cmdDesc)
		end
		
		local aTeam = spGetUnitAllyTeam(unitID)
		
		constructors = constructors + 1
		constructorTable[constructors] = unitID
		
		constructor[unitID]    = {allyTeam = aTeam, index = constructors}
		
		checkInterval = ceil(checkLoopFrames/constructors)
	end
	
	-- add structure to structure table
	if ud.isImmobile and not ud.customParams.mobilebuilding then
		RegisterStructure(unitID, ud)
	end
end

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Debug

local function toggleDebug(cmd, line, words, player)
	if not Spring.IsCheatingEnabled() then
		return
	end
	local unitID = tonumber(words[1])
	Spring.Echo("Debug terraform")
	if not unitID then
		debugMode = not debugMode
		Spring.Echo((debugMode and "Enabled") or "Disabled")
		debugModeUnitID = nil
		return
	end
	
	debugMode = true
	Spring.Echo("unitID", unitID)
	debugModeUnitID = debugModeUnitID or {}
	debugModeUnitID[unitID] = true
end

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Gadget API

local TerraformFunctions = {}
TerraformFunctions.IsPositionTerraformable = IsPositionTerraformable
TerraformFunctions.DoSmoothDirectly = DoSmoothDirectly

function TerraformFunctions.StructureAt(x, z)
	x, z = math.floor(x/8)*8, math.floor(z/8)*8
	return HasStructure(x, z)
end

function TerraformFunctions.ForceTerraformCompletion(pregame, needSaveHax)
	if pregame and needSaveHax then
		-- gadget:UnsyncedHeightMapUpdate seems to not be called pregame.
		wantForceCompleteFrameZero = true
		return
	end
	DoTerraformUpdate(Spring.GetGameFrame(), true)
	if pregame then
		GG.TerrainTexture.UpdateAll()
	end
end

function TerraformFunctions.TerraformArea(terraform_type, point, pointCount, terraformHeight, unit, constructorCount, teamID,
		volumeSelection, shift, commandX, commandZ, commandTag, disableForceCompletion, enableDecay)
	TerraformArea(terraform_type, point, pointCount, terraformHeight, unit, constructorCount, teamID, volumeSelection, shift, commandX, commandZ, commandTag, disableForceCompletion, not enableDecay)
end

function TerraformFunctions.TerraformWall(terraform_type, point, pointCount, terraformHeight, unit, constructorCount, teamID,
		volumeSelection, shift, commandX, commandZ, commandTag, disableForceCompletion, enableDecay)
	TerraformWall(terraform_type, point, pointCount, terraformHeight, unit, constructorCount, teamID, volumeSelection, shift, commandX, commandZ, commandTag, disableForceCompletion, not enableDecay)
end

function TerraformFunctions.TerraformRamp(startX, startY, startZ, endX, endY, endZ, width, unit, constructorCount,teamID,
		volumeSelection, shift, commandX, commandZ, commandTag, disableForceCompletion, enableDecay)
	TerraformRamp(startX, startY, startZ, endX, endY, endZ, width, unit, constructorCount,teamID, volumeSelection, shift, commandX, commandZ, commandTag, disableForceCompletion, not enableDecay)
end

function TerraformFunctions.SetStructureHeight(unitID, height)
	if structure[unitID] then
		structure[unitID].h = height
	end
end

function TerraformFunctions.SetFreeTerraform(newFreeTerraform)
	freeTerraform = newFreeTerraform
end

function TerraformFunctions.StructureMoveSetup(unitID, unitDefID)
	if structure[unitID] then
		DeregisterStructure(unitID)
	end
end

function TerraformFunctions.StructureMoveAftermath(unitID, unitDefID)
	unitDefID = unitDefID or Spring.GetUnitDefID(unitID)
	ud = UnitDefs[unitDefID]
	if ud.isImmobile and not ud.customParams.mobilebuilding then
		RegisterStructure(unitID, ud)
	end
end

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Initialise, check modoptions and register command

function gadget:Initialize()
	gadgetHandler:RegisterCMDID(CMD_TERRAFORM_INTERNAL)
	
	local terraformColor = {0.7, 0.75, 0, 0.7}
	
	Spring.SetCustomCommandDrawData(CMD_RAMP, "Ramp", terraformColor, false)
	Spring.SetCustomCommandDrawData(CMD_LEVEL, "Level", terraformColor, false)
	Spring.SetCustomCommandDrawData(CMD_RAISE, "Raise", terraformColor, false)
	Spring.SetCustomCommandDrawData(CMD_SMOOTH, "Smooth", terraformColor, false)
	Spring.SetCustomCommandDrawData(CMD_RESTORE, "Restore2", terraformColor, false)
	
	Spring.AssignMouseCursor("Ramp", "cursorRamp", true, true)
	Spring.AssignMouseCursor("Level", "cursorLevel", true, true)
	Spring.AssignMouseCursor("Raise", "cursorRaise", true, true)
	Spring.AssignMouseCursor("Smooth", "cursorSmooth", true, true)
	Spring.AssignMouseCursor("Restore2", "cursorRestore2", true, true)
	
	gadgetHandler:RegisterCMDID(CMD_RAMP)
	gadgetHandler:RegisterCMDID(CMD_LEVEL)
	gadgetHandler:RegisterCMDID(CMD_RAISE)
	gadgetHandler:RegisterCMDID(CMD_SMOOTH)
	gadgetHandler:RegisterCMDID(CMD_RESTORE)
	
	GG.Terraform = TerraformFunctions
	
	gadgetHandler:AddChatAction("debugterra", toggleDebug, "Debugs terraform.")
	
	for _, unitID in ipairs(Spring.GetAllUnits()) do
		local unitDefID = Spring.GetUnitDefID(unitID)
		local teamID = spGetUnitTeam(unitID)
		gadget:UnitCreated(unitID, unitDefID, teamID)
	end
end

--------------------------------------------------------------------------------
-- SYNCED
--------------------------------------------------------------------------------

else

--------------------------------------------------------------------------------
-- UNSYNCED
--------------------------------------------------------------------------------

local terraunitDefID = UnitDefNames["terraunit"].id
local terraUnits = {}

function gadget:Initialize()
	for _, unitID in ipairs(Spring.GetAllUnits()) do
		local unitDefID = Spring.GetUnitDefID(unitID)
		local teamID = Spring.GetUnitTeam(unitID)
		gadget:UnitCreated(unitID, unitDefID, teamID)
	end
end


function gadget:UnitCreated(unitID, unitDefID, teamID)
	if unitDefID == terraunitDefID then
		terraUnits[unitID] = true
		Spring.UnitRendering.SetUnitLuaDraw(unitID, true)
	end
end

function gadget:UnitDestroyed(unitID, unitDefID)
	if terraUnits[unitID] then
		terraUnits[unitID] = nil
	end
end

function gadget:DrawUnit(unitID, drawMode)
	if terraUnits[unitID] then
		return true --suppress engine drawing
	end
end

--------------------------------------------------------------------------------
-- UNSYNCED
--------------------------------------------------------------------------------
end