Semi-automatic build

 Players = :()
 UserInputService = :()
 RunService = :()
 TweenService = :()

 player = Players.LocalPlayer
 playerGui = player:()


 lastTarget1, lastTarget2, lastDir
 currentVec1, currentVec2 = .zero, .zero

 listenState =  
 tempStart1, tempStart2, tempEnd1, tempEnd2

 inputsLeft, inputsRight = {}, {}

 settingsData = {
	repeatCount = ,
	buildDir = .(, , ),
	thickness = ,
	buildDelay = ,
	baseSize = ,
	baseLayers = ,
	baseOffset = ,
	pillarHeight = ,
	wallHeight = ,
	wallLength = ,
	autoSnapYaw = ,
}

 snapYawConnection = 


  (num)
	 num  .(num *  + ) /   


  (vec)
	 .((vec.X), (vec.Y), (vec.Z))


  (num)
	 .(, (num))


  (textBox)
	 num = (textBox.Text)
	 num  textBox.Text = (num) 


  (inputs, vec, startIndex)
	startIndex = startIndex  
	inputs[startIndex].Text = (vec.X)
	inputs[startIndex + ].Text = (vec.Y)
	inputs[startIndex + ].Text = (vec.Z)


  (str, defaultVec)
	  str  str ==    defaultVec 
	 coords = {}
	 num  .(str, ) 
		 p = (num)
		 p  .(coords, (p)) 
	
	 #coords >=   .(coords[], coords[], coords[])  defaultVec



  (className, props)
	 inst = .(className)
	 k, v  (props) 
		inst[k] = v
	
	 inst



 plankESPFolder = (, { Name = , Parent =  })
 plankESPParts = {}

  (a, b)
	 a  b  a.X == b.X  a.Y == b.Y  a.Z == b.Z


  (number)
	 plankESPParts[number]  plankESPParts[number].part 
		plankESPParts[number].part:()
	
	plankESPParts[number] = 


  (number, position)
	position = (position)
	 existing = plankESPParts[number]
	 existing  existing.part  existing.part.Parent  (existing.position, position) 
		
	

	(number)

	 part = (, {
		Name =  .. number,
		Anchored = , CanCollide = , CanTouch = , CanQuery = ,
		Transparency = , Size = .(, , ),
		 = .(position), Parent = plankESPFolder
	})

	 billboard = (, {
		Name =  .. number, Adornee = part, AlwaysOnTop = ,
		LightInfluence = , MaxDistance = .huge, Size = .(, ),
		StudsOffsetWorldSpace = .(, , ), Enabled = , Parent = part
	})

	 label = (, {
		Name = , BackgroundTransparency = , BorderSizePixel = ,
		Size = .(, ), Font = .Font.GothamBlack,
		Text = (number), TextColor3 = .(, , ),
		TextSize = , TextStrokeColor3 = .(, , ), TextStrokeTransparency = , Parent = billboard
	})

	plankESPParts[number] = { part = part, billboard = billboard, label = label, position = position }


  (inputs, startIndex)
	  inputs    
	 x, y, z = (inputs[startIndex]  inputs[startIndex].Text), (inputs[startIndex+]  inputs[startIndex+].Text), (inputs[startIndex+]  inputs[startIndex+].Text)
	 (x  y  z)  (.(x, y, z))  


  ()
	 positions = {
		(inputsLeft, ),  (inputsLeft, ),
		(inputsRight, ), (inputsRight, ),
	}

	 i = ,  
		 pos = positions[i]
		 pos 
			 existing = plankESPParts[i]
			 existing  existing.part  existing.part.Parent 
				  (existing.position, pos) 
					existing.part.CFrame = .(pos)
					existing.position = pos
				
			
				(i, pos)
			
		
			(i)
		
	



 TWEEN_FAST = TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out)

  (instance, tweenInfo, properties)
	 tween = TweenService:(instance, tweenInfo, properties)
	tween:()
	 tween


 THEME = { border = .(, , ), accentA = .(, , ) }
 COLOR = {
	ink = .(, , ), surface = .(, , ), surface2 = .(, , ),
	border = .(, , ), text = .(, , ), textMuted = .(, , ),
	accent = .(, , ), stepBg = .(, , ), listening = .(, , ),
	baseplateBg = .(, , ), pillarBg = .(, , ), wallBg = .(, , ),
	settingsBg = .(, , ), offRed = .(, , ), onGreen = .(, , ),
}

  (button)
	 scale = (, { Parent = button })
	  (input, targetScale)
		 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
			(scale, TWEEN_FAST, { Scale = targetScale })
		
	
	button.InputBegan:((input) (input, ) )
	button.InputEnded:((input) (input, ) )



 screenGui = (, { Name = , ResetOnSpawn = , ZIndexBehavior = .ZIndexBehavior.Sibling, Parent = playerGui })

 panel = (, {
	Name = , AnchorPoint = .(, ), Position = .(, ),
	Size = .(, ), BackgroundColor3 = COLOR.surface, BorderSizePixel = ,
	Visible = , ZIndex = , Parent = screenGui
})
(, { CornerRadius = .(, ), Parent = panel })
(, { Color = COLOR.border, Thickness = , Parent = panel })
(, { PaddingTop = .(, ), PaddingBottom = .(, ), PaddingLeft = .(, ), PaddingRight = .(, ), Parent = panel })

 title = (, {
	Name = , BackgroundTransparency = , Size = .(, , , ),
	Font = .Font.GothamBold, TextSize = , TextColor3 = COLOR.textMuted,
	TextXAlignment = .TextXAlignment.Left, Text = , ZIndex = , Parent = panel
})


 settingsPanel = (, {
	Name = , Size = .(, , , ), Position = .(, , , ),
	BackgroundColor3 = COLOR.settingsBg, BorderSizePixel = , ZIndex = , Parent = panel
})
(, { CornerRadius = .(, ), Parent = settingsPanel })
(, { Color = COLOR.border, Thickness = , Parent = settingsPanel })
(, { PaddingTop = .(, ), PaddingBottom = .(, ), PaddingLeft = .(, ), PaddingRight = .(, ), Parent = settingsPanel })

(, {
	BackgroundTransparency = , Size = .(, , , ), Font = .Font.GothamBold,
	TextSize = , TextColor3 = COLOR.accent, TextXAlignment = .TextXAlignment.Left,
	Text = , ZIndex = , Parent = settingsPanel
})

 settingsContent = (, {
	BackgroundTransparency = , Size = .(, , , -), Position = .(, , , ),
	CanvasSize = .(, , , ), ScrollBarThickness = , ScrollBarImageColor3 = COLOR.accent,
	BorderSizePixel = , ZIndex = , Parent = settingsPanel
})
(, { FillDirection = .FillDirection.Vertical, Padding = .(, ), SortOrder = .SortOrder.LayoutOrder, Parent = settingsContent })

  (layoutOrder)
	 row = (, { BackgroundTransparency = , Size = .(, -, , ), LayoutOrder = layoutOrder, ZIndex = , Parent = settingsContent })
	(, { FillDirection = .FillDirection.Horizontal, Padding = .(, ), SortOrder = .SortOrder.LayoutOrder, Parent = row })
	 row


  (parent, labelText, defaultVal, widthScale, layoutOrder)
	 container = (, { BackgroundTransparency = , Size = .(widthScale  , -, , ), LayoutOrder = layoutOrder, ZIndex = , Parent = parent })
	(, { BackgroundTransparency = , Size = .(, , , ), Font = .Font.GothamMedium, TextSize = , TextColor3 = COLOR.textMuted, TextXAlignment = .TextXAlignment.Left, Text = labelText, ZIndex = , Parent = container })
	
	 boxFrame = (, { Size = .(, , , ), Position = .(, , , ), BackgroundColor3 = COLOR.surface2, BorderSizePixel = , ZIndex = , Parent = container })
	(, { CornerRadius = .(, ), Parent = boxFrame })
	(, { Color = COLOR.border, Thickness = , Parent = boxFrame })

	 (, { BackgroundTransparency = , Size = .(, ), Font = .Font.Gotham, TextSize = , TextColor3 = COLOR.text, Text = defaultVal, ClearTextOnFocus = , ZIndex = , Parent = boxFrame })


  (parent, labelText, defaultState, layoutOrder)
	 container = (, { BackgroundTransparency = , Size = .(, -, , ), LayoutOrder = layoutOrder  , ZIndex = , Parent = parent })
	(, { BackgroundTransparency = , Size = .(, , , ), Font = .Font.GothamMedium, TextSize = , TextColor3 = COLOR.textMuted, TextXAlignment = .TextXAlignment.Left, Text = labelText, ZIndex = , Parent = container })

	 btn = (, {
		Size = .(, , , ), Position = .(, , , ),
		BackgroundColor3 = defaultState  COLOR.onGreen  COLOR.offRed, Font = .Font.GothamBold,
		TextSize = , TextColor3 = COLOR.text, Text = defaultState    , ZIndex = , Parent = container
	})
	(, { CornerRadius = .(, ), Parent = btn })
	(, { Color = COLOR.border, Thickness = , Parent = btn })
	 btn



 row1, row2, row3, row4, row5 = (), (), (), (), ()
 setLoopInput        = (row1, , , )
 setThickInput       = (row1, , , )
 setSpeedInput       = (row2, , , )
 setDirInput         = (row2, , , )
 setBaseSizeInput    = (row3, , , )
 setBaseLayerInput   = (row3, , , )
 setBaseOffsetInput  = (row4, , , )
 setPillarHeightInput= (row4, , , )
 setWallHeightInput  = (row5, , , )
 setWallLengthInput  = (row5, , , )
 snapYawBtn          = (settingsContent, , , )

  ()
	settingsData.repeatCount  = (setLoopInput.Text)  
	settingsData.buildDir     = (setDirInput.Text, .(, , ))
	settingsData.thickness    = .(.((setThickInput.Text)  ), , )
	settingsData.buildDelay   = .((setSpeedInput.Text)  , , )
	settingsData.baseSize     = setBaseSizeInput.Text ~=   setBaseSizeInput.Text  
	settingsData.baseLayers   = .((setBaseLayerInput.Text)  , , )
	settingsData.baseOffset   = (setBaseOffsetInput.Text)  
	settingsData.pillarHeight = (setPillarHeightInput.Text)  
	settingsData.wallHeight   = (setWallHeightInput.Text)  
	settingsData.wallLength   = (setWallLengthInput.Text)  


 _, input  ({setLoopInput, setDirInput, setThickInput, setSpeedInput, setBaseSizeInput, setBaseLayerInput, setBaseOffsetInput, setPillarHeightInput, setWallHeightInput, setWallLengthInput}) 
	input.FocusLost:(updateSettingsFromUI)



snapYawBtn.MouseButton1Click:(()
	settingsData.autoSnapYaw =  settingsData.autoSnapYaw
	snapYawBtn.BackgroundColor3 = settingsData.autoSnapYaw  COLOR.onGreen  COLOR.offRed
	snapYawBtn.Text = settingsData.autoSnapYaw    
	
	 snapYawConnection  snapYawConnection:() snapYawConnection =  
	 settingsData.autoSnapYaw 
		snapYawConnection = RunService.RenderStepped:(()
			 hrp = player.Character  player.Character:()
			 hrp 
				 yaw = .(.(-hrp.CFrame.LookVector.X, -hrp.CFrame.LookVector.Z))
				hrp.CFrame = .(hrp.Position) * .(, .(.(yaw / ) * ), )
			
		)
	
)


 panelDragging, panelDragStart, panelStartPos
title.InputBegan:((input)
	 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
		panelDragging, panelDragStart, panelStartPos = , input.Position, panel.Position
		input.Changed:(()
			 input.UserInputState == .UserInputState.End  panelDragging =  
		)
	
)

UserInputService.InputChanged:((input)
	 panelDragging  (input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch) 
		 delta = input.Position - panelDragStart
		panel.Position = .(panelStartPos.X.Scale, panelStartPos.X.Offset + delta.X, panelStartPos.Y.Scale, panelStartPos.Y.Offset + delta.Y)
	
)


  (parent, layoutOrder, placeholderText)
	 slot = (, { Name = , Size = .(, , , ), LayoutOrder = layoutOrder, BackgroundColor3 = COLOR.surface2, BorderSizePixel = , ZIndex = , Parent = parent })
	(, { CornerRadius = .(, ), Parent = slot })
	(, { Color = COLOR.border, Thickness = , Parent = slot })

	 textBox = (, {
		Name = , BackgroundTransparency = , Size = .(, ),
		Font = .Font.Gotham, TextSize = , TextColor3 = COLOR.text,
		PlaceholderColor3 = COLOR.textMuted, PlaceholderText = placeholderText, Text = ,
		ClearTextOnFocus = , ZIndex = , Parent = slot
	})
	textBox.FocusLost:(() (textBox) )
	 textBox


  (labelText, xScale, storageTable)
	 column = (, { BackgroundTransparency = , Size = .(, , , ), Position = .(xScale, , , ), ZIndex = , Parent = panel })
	(, { FillDirection = .FillDirection.Vertical, Padding = .(, ), SortOrder = .SortOrder.LayoutOrder, Parent = column })
	(, { BackgroundTransparency = , Size = .(, , , ), LayoutOrder = , Font = .Font.GothamBold, TextSize = , TextColor3 = COLOR.accent, TextXAlignment = .TextXAlignment.Left, Text = labelText, Parent = column })

	 placeholders = { , , , , ,  }
	 i = ,  
		 i ==  
			(, { BackgroundTransparency = , Size = .(, , , ), LayoutOrder = , Font = .Font.GothamMedium, TextSize = , TextColor3 = COLOR.textMuted, TextXAlignment = .TextXAlignment.Left, Text = , Parent = column })
		
		storageTable[i] = (column, i <=   i  i + , placeholders[i])
	


(, , inputsLeft)
(, , inputsRight)

()
RunService.RenderStepped:(refreshESPFromInputs)


 bottomFrame = (, { BackgroundTransparency = , Size = .(, , , ), Position = .(, , , -), ZIndex = , Parent = panel })
(, { FillDirection = .FillDirection.Horizontal, Padding = .(, ), SortOrder = .SortOrder.LayoutOrder, Parent = bottomFrame })

  (text, sizeScale, bgCol, textCol, order)
	 btn = (, { Size = .(sizeScale, , , ), LayoutOrder = order, BackgroundColor3 = bgCol, Font = .Font.GothamBold, TextSize = , TextColor3 = textCol, Text = text, ZIndex = , Parent = bottomFrame })
	(, { CornerRadius = .(, ), Parent = btn })
	 btn


 updateButton   = (, , COLOR.accent, COLOR.ink, )

 actionButton   = (, { Size = .(, , , ), LayoutOrder = , BackgroundColor3 = COLOR.stepBg, BorderSizePixel = , ZIndex = , Parent = bottomFrame })
(, { CornerRadius = .(, ), Parent = actionButton })
(, { ApplyStrokeMode = .ApplyStrokeMode.Border, Color = COLOR.border, Thickness = , Transparency = , Parent = actionButton })

 actionSingleButton = (, { Size = .(, ), BackgroundTransparency = , BorderSizePixel = , AutoButtonColor = , Font = .Font.GothamBold, TextSize = , TextColor3 = COLOR.text, Text = , ZIndex = , Parent = actionButton })
 actionUndoButton   = (, { Size = .(, , , ), BackgroundColor3 = COLOR.stepBg, BorderSizePixel = , AutoButtonColor = , Font = .Font.GothamBold, TextSize = , TextColor3 = COLOR.text, Text = , ZIndex = , Visible = , Parent = actionButton })
 actionContinueButton = (, { Size = .(, , , ), Position = .(, , , ), BackgroundColor3 = COLOR.accent, BorderSizePixel = , AutoButtonColor = , Font = .Font.GothamBold, TextSize = , TextColor3 = COLOR.ink, Text = , ZIndex = , Visible = , Parent = actionButton })
(, { CornerRadius = .(, ), Parent = actionUndoButton })
(, { CornerRadius = .(, ), Parent = actionContinueButton })

 actionDivider = (, { Size = .(, , , -), Position = .(, , , ), BackgroundColor3 = COLOR.border, BackgroundTransparency = , BorderSizePixel = , ZIndex = , Visible = , Parent = actionButton })

  (text, backgroundColor, textColor)
	actionSingleButton.Visible = 
	actionSingleButton.Text = text  
	actionSingleButton.TextColor3 = textColor  COLOR.text
	actionButton.BackgroundColor3 = backgroundColor  COLOR.stepBg
	actionUndoButton.Visible, actionContinueButton.Visible, actionDivider.Visible = , , 


  (backgroundLeft, backgroundRight, continueText)
	actionSingleButton.Visible = 
	actionUndoButton.Visible, actionContinueButton.Visible, actionDivider.Visible = , , 
	actionUndoButton.BackgroundColor3 = backgroundLeft  COLOR.stepBg
	actionContinueButton.BackgroundColor3 = backgroundRight  COLOR.accent
	actionContinueButton.Text = continueText  
	actionButton.BackgroundColor3 = backgroundLeft  COLOR.stepBg


 baseplateButton = (, , COLOR.baseplateBg, COLOR.text, )
 pillarButton    = (, , COLOR.pillarBg, COLOR.text, )
 wallButton      = (, , COLOR.wallBg, COLOR.text, )


 oldNamecall
oldNamecall = (, , ((self, ...)
	 method = ()
	 args = {...}

	 (method ==   method == )  self.Name ==  
		 #args >=   (args[]) ==   (args[]) ==  
			 v1, v2 = (args[]), (args[])
			currentVec1, currentVec2 = v1, v2

			(inputsLeft, v1, )
			(inputsRight, v2, )

			 #args ==  
				lastTarget1, lastTarget2, lastDir = args[], args[], args[]
			
				lastDir = args[]
			

			 listenState ==  
				tempStart1, tempStart2 = v1, v2
				listenState = 
				(COLOR.surface2, COLOR.accent, )
			 listenState ==  
				tempEnd1, tempEnd2 = v1, v2
				 altEnd = (tempEnd1 + tempEnd2) * 
				(inputsLeft, tempStart1, )
				(inputsRight, altEnd, )
				listenState = 
				(COLOR.surface2, COLOR.accent, )
			

			args[], args[] = v1, v2
		
	
	 (self, (args))
))


  (hammer, event, timeout)
	 lastTarget1  lastTarget2    
	timeout = timeout  
	(()
		 hammer  hammer:()  hammer:() 
	)
	 deadline = .() + timeout
	 .() < deadline 
		 lastTarget1  lastTarget2    
		.()
	
	 lastTarget1 ~=   lastTarget2 ~= 


  (start1, end1, start2, end2, callback)
	()
	 char = player.Character
	 hammer = char  char:()
	 event = hammer  hammer:()

	  event  ( lastTarget1   (hammer, event, )) 
		 callback  (,  event    ) 
		
	

	 diff1, diff2 = end1 - start1, end2 - start2
	 maxDist = .(.(diff1.X), .(diff1.Y), .(diff1.Z), .(diff2.X), .(diff2.Y), .(diff2.Z))
	 steps = .(, .((maxDist / ) + ))
	 finalDir = settingsData.buildDir  lastDir  .(, , )

	.(()
		 _ = , settingsData.repeatCount 
			 prevP1, prevP2
			 i = , steps 
				 alpha = i / steps
				 curr1, curr2 = (start1:(end1, alpha)), (start2:(end2, alpha))

				  (p1, p2)
					 lastTarget1  lastTarget2 
						event:(p1, p2, lastTarget1, lastTarget2, finalDir)
						 
					
					 
				

				  (curr1, curr2) 
					 callback  (, ) 
					
				

				 thickness = .(.(settingsData.thickness  ), , )
				 thickness >=   prevP1  prevP2 
					 t = , thickness -  
						 ratio = t / thickness
						((prevP1:(curr1, ratio)), (prevP2:(curr2, ratio)))
					
				

				prevP1, prevP2 = curr1, curr2
				.(settingsData.buildDelay)
			
			.()
		
		 callback  () 
	)



  (hrp)
	 rawLook = hrp.CFrame.LookVector
	 flatLook = .(rawLook.X, , rawLook.Z)
	flatLook = flatLook.Magnitude <   .(, , -)  flatLook.Unit
	 flatLook, .(-flatLook.Z, , flatLook.X)



  (btn, defaultText)
	 char = player.Character
	 hrp, humanoid = char  char:(), char  char:()
	  hrp   humanoid 
		btn.Text = 
		.(, () btn.Text = defaultText )
		 , 
	
	 hrp, humanoid



updateButton.MouseButton1Click:(()
	 i = ,  
		(inputsLeft[i])
		(inputsRight[i])
	

	 start1 = .((inputsLeft[].Text)  , (inputsLeft[].Text)  , (inputsLeft[].Text)  )
	 end1   = .((inputsLeft[].Text)  start1.X, (inputsLeft[].Text)  start1.Y, (inputsLeft[].Text)  start1.Z)
	 start2 = .((inputsRight[].Text)  , (inputsRight[].Text)  , (inputsRight[].Text)  )
	 end2   = .((inputsRight[].Text)  start2.X, (inputsRight[].Text)  start2.Y, (inputsRight[].Text)  start2.Z)

	()
	(start1, end1, start2, end2, (success, msg)
		updateButton.Text = success    (msg  )
		.(, () updateButton.Text =  )
	)
)

baseplateButton.MouseButton1Click:(()
	()
	 hrp, humanoid = (baseplateButton, )
	  hrp   

	 rows, cols = , 
	 rStr, cStr = .(settingsData.baseSize  , )
	 rStr  cStr 
		rows, cols = .(, (rStr)  ), .(, (cStr)  )
	
		 singleNum = .(settingsData.baseSize  , )
		 singleNum  rows = .(, (singleNum)  ); cols = rows 
	

	baseplateButton.Text = 

	 footPos = hrp.Position - .(, (hrp.Size.Y / ) + humanoid.HipHeight + settingsData.baseOffset, )
	 curX, curY, curZ = .((footPos.X / ) + ) * , .((footPos.Y / ) + ) * , .((footPos.Z / ) + ) * 
	 totalWidthX, totalWidthZ = rows * , cols * 
	 xCount, zCount = .(totalWidthX / ), .(totalWidthZ / )

	 flatLook, rightVector = (hrp)
	 baseCenter = .(curX, curY, curZ)
	 halfWidthX, halfWidthZ = totalWidthX * , totalWidthZ * 

	.(()
		  (layerNum, isLayer2)
			baseplateButton.Text = .(, layerNum, rows, cols)
			 count = isLayer2  xCount  zCount

			 i = , count -  
				 l1 = (isLayer2  -halfWidthX  -halfWidthZ) + (i * )
				 l2 = .(l1 + , isLayer2  halfWidthX  halfWidthZ)
				 l1 > (isLayer2  halfWidthX  halfWidthZ) -   l1 = (isLayer2  halfWidthX  halfWidthZ) -  

				 dir1 = isLayer2  rightVector  flatLook
				 dir2 = isLayer2  flatLook  rightVector
				 span = isLayer2  halfWidthZ  halfWidthX

				 c1, c2 = baseCenter + dir1 * l1, baseCenter + dir1 * l2
				 s1, e1 = c1 - dir2 * span, c1 + dir2 * span
				 s2, e2 = c2 - dir2 * span, c2 + dir2 * span

				(inputsLeft, s1, );  (inputsLeft, e1, )
				(inputsRight, s2, ); (inputsRight, e2, )

				 completedEvent = .()
				(s1, e1, s2, e2, () completedEvent:() )
				completedEvent.Event:()
				completedEvent:()
				.()
			
		

		(, )
		 settingsData.baseLayers >=   (, ) 

		baseplateButton.Text = 
		.(, () baseplateButton.Text =  )
	)
)

pillarButton.MouseButton1Click:(()
	()
	 hrp, humanoid = (pillarButton, )
	  hrp   

	pillarButton.Text = 
	 footPos = (hrp.Position - .(, (hrp.Size.Y / ) + humanoid.HipHeight, ))
	 _, rightVector = (hrp)

	 centerPos = .((footPos.X), (footPos.Y), (footPos.Z))
	 pos1, pos2 = centerPos - rightVector, centerPos + rightVector

	 start1 = .((pos1.X), (footPos.Y), (pos1.Z))
	 end1   = .((pos1.X), (footPos.Y + settingsData.pillarHeight), (pos1.Z))
	 start2 = .((pos2.X), (footPos.Y), (pos2.Z))
	 end2   = .((pos2.X), (footPos.Y + settingsData.pillarHeight), (pos2.Z))

	(inputsLeft, start1, );  (inputsLeft, end1, )
	(inputsRight, start2, ); (inputsRight, end2, )

	(start1, end1, start2, end2, (success, msg)
		pillarButton.Text = success    (msg  )
		.(, () pillarButton.Text =  )
	)
)

wallButton.MouseButton1Click:(()
	()
	 hrp, humanoid = (wallButton, )
	  hrp   

	wallButton.Text = 
	 footPos = (hrp.Position - .(, (hrp.Size.Y / ) + humanoid.HipHeight, ))
	 wallHeightOffset, halfLength = settingsData.wallHeight * , settingsData.wallLength * 
	 _, rightVector = (hrp)
	 lengthVec = rightVector * halfLength

	 pos1, pos2 = footPos - lengthVec, footPos + lengthVec
	 start1 = .((pos1.X), (footPos.Y), (pos1.Z))
	 end1   = .((pos1.X), (footPos.Y + wallHeightOffset), (pos1.Z))
	 start2 = .((pos2.X), (footPos.Y), (pos2.Z))
	 end2   = .((pos2.X), (footPos.Y + wallHeightOffset), (pos2.Z))

	(inputsLeft, start1, );  (inputsLeft, end1, )
	(inputsRight, start2, ); (inputsRight, end2, )

	(start1, end1, start2, end2, (success, msg)
		wallButton.Text = success    (msg  )
		.(, () wallButton.Text =  )
	)
)


  ()
	listenState = 
	(, COLOR.stepBg, COLOR.text)
	tempStart1, tempStart2, tempEnd1, tempEnd2 = , , , 


actionUndoButton.MouseButton1Click:(()
	 listenState ==  
		()
	 listenState ==  
		tempEnd1, tempEnd2 = , 
		listenState = 
		(, COLOR.surface2, COLOR.text)
	
)

actionContinueButton.MouseButton1Click:(()
	 listenState ==  
		listenState = 
		(, COLOR.listening, COLOR.text)
	 listenState ==  
		(, COLOR.accent, COLOR.ink)
		listenState = 
	
)

actionSingleButton.MouseButton1Click:(()
	 listenState ==  
		listenState = 
		(, COLOR.listening, COLOR.text)
	 listenState ==   listenState ==  
		listenState = 
		(, COLOR.listening, COLOR.text)
	 listenState ==  
		  tempStart1   tempEnd1   tempStart2   tempEnd2 
			(, COLOR.stepBg, COLOR.text)
			.(, ()  listenState ==   (, COLOR.accent, COLOR.ink)  )
			
		

		(, COLOR.accent, COLOR.ink)
		(tempStart1, tempEnd1, tempStart2, tempEnd2, (success, msg)
			(success    (msg  ), COLOR.accent, COLOR.ink)
			.(success    )
			()
		)
	
)


 handle = (, { Name = , Size = .(, ), Position = .(, -, , -), BackgroundColor3 = COLOR.ink, BorderSizePixel = , AutoButtonColor = , Text = , ZIndex = , Parent = screenGui })
(, { CornerRadius = .(, ), Parent = handle })

 handleStroke = (, { Name = , ApplyStrokeMode = .ApplyStrokeMode.Border, Color = THEME.border, Thickness = , Transparency = , Parent = handle })

 _, btn  ({handle, actionSingleButton, actionUndoButton, actionContinueButton})  (btn) 

 dotsHolder = (, { BackgroundTransparency = , Size = .(, ), Position = .(, -, , -), ZIndex = , Parent = handle })
(, { CellSize = .(, ), CellPadding = .(, ), FillDirectionMaxCells = , Parent = dotsHolder })

 dots = {}
 i = ,  
	 dot = (, { Size = .(, ), BackgroundColor3 = COLOR.textMuted, BorderSizePixel = , ZIndex = , Parent = dotsHolder })
	(, { CornerRadius = .(, ), Parent = dot })
	dots[i] = dot


 panelOpen = 
  (open)
	panelOpen = open
	panel.Visible = open
	(handleStroke, TWEEN_FAST, { Color = open  THEME.accentA  THEME.border })
	 _, dot  (dots) 
		(dot, TWEEN_FAST, { BackgroundColor3 = open  THEME.accentA  COLOR.textMuted })
	


 dragging, moved, dragInput, dragStart, startPos = , 
 DRAG_THRESHOLD = 

handle.InputBegan:((input)
	 input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
		dragging, moved, dragStart, startPos = , , input.Position, handle.Position
		input.Changed:(()
			 input.UserInputState == .UserInputState.End 
				dragging = 
				  moved  ( panelOpen) 
			
		)
	
)

handle.InputChanged:((input)
	 input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch 
		dragInput = input
	
)

UserInputService.InputChanged:((input)
	 dragging  input == dragInput 
		 delta = input.Position - dragStart
		  moved  delta.Magnitude > DRAG_THRESHOLD  moved =  
		 moved 
			handle.Position = .(startPos.X.Scale, startPos.X.Offset + delta.X, startPos.Y.Scale, startPos.Y.Offset + delta.Y)
		
	
)