Auto farm and more Open source

 rs=:()
 plrs=:()
 run=:()
 lp=plrs.LocalPlayer
 rf=(:())()

 thm={
	TextColor=.(,,),Background=.(,,),Topbar=.(,,),Shadow=.(,,),
	NotificationBackground=.(,,),NotificationActionsBackground=.(,,),
	TabBackground=.(,,),TabStroke=.(,,),TabBackgroundSelected=.(,,),
	TabTextColor=.(,,),SelectedTabTextColor=.(,,),
	ElementBackground=.(,,),ElementBackgroundHover=.(,,),
	SecondaryElementBackground=.(,,),ElementStroke=.(,,),SecondaryElementStroke=.(,,),
	SliderBackground=.(,,),SliderProgress=.(,,),SliderStroke=.(,,),
	ToggleBackground=.(,,),ToggleEnabled=.(,,),ToggleDisabled=.(,,),
	ToggleEnabledStroke=.(,,),ToggleDisabledStroke=.(,,),
	ToggleEnabledOuterStroke=.(,,),ToggleDisabledOuterStroke=.(,,),
	DropdownSelected=.(,,),DropdownUnselected=.(,,),
	InputBackground=.(,,),InputStroke=.(,,),PlaceholderColor=.(,,)
}

 win=rf:({
	Name=,Icon=,LoadingTitle=,LoadingSubtitle=,
	ShowText=,Theme=thm,ToggleUIKeybind=,DisableRayfieldPrompts=,DisableBuildWarnings=,
	ConfigurationSaving={Enabled=,FolderName=,FileName=},
	Discord={Enabled=,Invite=,RememberJoins=},KeySystem=
})

  (t,c) rf:({Title=t,Content=c,Duration=,Image=}) 
 fnt=Font.(,.FontWeight.Bold)

  (m)
	 m:()  m.PrimaryPart  m:()


  (bag,m,tag,fill,out,tc,dc)
	 bag[m]   
	 r=(m)
	  r   
	 head=m:()
	 ad=head  r
	 hl=.()
	hl.Adornee=m
	hl.DepthMode=.HighlightDepthMode.AlwaysOnTop
	hl.FillColor=fill
	hl.FillTransparency=
	hl.OutlineColor=out
	hl.OutlineTransparency=
	hl.Parent=m
	 holdf=lp:()
	 holdf 
		 fold=holdf:()
		  fold 
			fold=.()
			fold.Name=
			fold.Parent=holdf
		
		holdf=fold
	
		holdf=m
	
	 bb=.()
	bb.Name=
	bb.Adornee=ad
	bb.AlwaysOnTop=
	bb.LightInfluence=
	bb.Size=.(,)
	bb.StudsOffset=.(,head    ,)
	bb.MaxDistance=
	bb.Parent=holdf
	 hold=.(,bb)
	hold.BackgroundTransparency=
	hold.Size=.(,)
	 lay=.(,hold)
	lay.HorizontalAlignment=.HorizontalAlignment.Center
	lay.VerticalAlignment=.VerticalAlignment.Top
	lay.Padding=.(,)
	lay.SortOrder=.SortOrder.LayoutOrder
	  (txt,sz,col,ord,h)
		 t=.(,hold)
		t.BackgroundTransparency=
		t.Size=.(,,,h)
		t.FontFace=fnt
		t.TextSize=sz
		t.TextColor3=col
		t.Text=txt
		t.TextYAlignment=.TextYAlignment.Center
		t.LayoutOrder=ord
		 s=.(,t)
		s.Color=.(,,)
		s.Transparency=
		s.Thickness=
		 t
	
	 namel=(tag,,tc,,)
	 distl=(,,dc,,)
	bag[m]={hl=hl,bb=bb,tx=distl,nm=namel,ad=ad}


  (bag,m)
	 d=bag[m]
	  d   
	 d.hl  d.hl:() 
	 d.bb  d.bb:() 
	bag[m]=


  (bag)
	 m  (bag)  (bag,m) 


  (bag,on)
	  on   
	 hrp=lp.Character  lp.Character:()
	  hrp   
	 m,d  (bag) 
		  m.Parent  (bag,m)  
		 r=d.ad
		  r   r.Parent 
			r=m:()  (m)
			d.ad=r
			 d.bb  r 
				d.bb.Adornee=r
				d.bb.StudsOffset=.(,r.Name==    ,)
			
		
		 from=(m)  r
		 from  d.tx  d.tx.Text=.((hrp.Position-from.Position).Magnitude+).. 
	


 kon,kbag,kacc=,{},
 kf=.(,,)
 ko=.(,,)
 kt=.(,,)
 kd=.(,,)
 pon,pbag,pacc=,{},
 pf=.(,,)
 po=.(,,)
 pt=.(,,)
 pd=.(,,)

  (m)
	  m   m:()    
	 m:()==    
	 m:()==    
	 n=.(m.Name)
	 n:()  n:()    
	 par=m.Parent
	 par  (par.Name==  par.Name==)    
	 pl=plrs:(m)
	 pl  pl:()==    
	 


  (m)
	 pl=plrs:(m)
	  pl    
	 n=pl.DisplayName
	 n==  n=pl.Name 
	 n..


  (m)
	  (m)   
	 pbag[m]  (pbag,m) 
	(kbag,m,(m),kf,ko,kt,kd)


  ()
	 _,nm  ({,}) 
		 f=:(nm)
		 f 
			 _,c  (f:()) 
				 (c)  (c) 
			
		
	
	 _,pl  (plrs:()) 
		 pl~=lp  pl.Character  (pl.Character) 
			(pl.Character)
		
	
	 m  (kbag) 
		  m.Parent   (m)  (kbag,m) 
	


  (nm)
	 f=:(nm)
	  f   
	f.ChildAdded:((c)
		.()
		 kon  (c)  (c) 
	)
	f.ChildRemoved:((c) (kbag,c) )

()
()
.ChildAdded:((c)
	 c.Name==  c.Name== 
		(c.Name)
		 kon  () 
	
)

  ()
	 live={}
	 _,pl  (plrs:()) 
		 pl~=lp  pl.Character  (pl.Character) 
			 ch=pl.Character
			 kon  (ch) 
				(pbag,ch)
			
				live[ch]=
				 tag=pl.DisplayName
				 tag==  tag=pl.Name 
				(pbag,ch,tag,pf,po,pt,pd)
			
		
	
	 m  (pbag) 
		  live[m]  (pbag,m) 
	


  (pl)
	 pl==lp   
	pl.CharacterAdded:((m)
		.()
		 kon  (m) 
			(m)
			
		
		 pon 
			 tag=pl.DisplayName
			 tag==  tag=pl.Name 
			(pbag,m,tag,pf,po,pt,pd)
		
	)
	pl.CharacterRemoving:((m)
		(pbag,m)
		(kbag,m)
	)

 _,pl  (plrs:())  (pl) 
plrs.PlayerAdded:(hookp)
plrs.PlayerRemoving:((pl)
	 pl.Character 
		(pbag,pl.Character)
		(kbag,pl.Character)
	
)

run.RenderStepped:((dt)
	 kon 
		kacc+=dt
		 kacc>=  kacc= () 
		(kbag,)
	
	 pon 
		pacc+=dt
		 pacc>=  pacc= () 
		(pbag,)
	
)

  ()
	 a=rs:()
	 r=a  a:()
	 p=r  r:()
	 p  p:()


 land,aud,unlk=,,
 wson,inf,clip=,,
 wsval=
 uis=:()
 fon=
 fcd=
 fspd=
 fhop=
 ffall=-
 fdir=.(,,)
 fret
 fws,fjh,fjp,fuj
 fax,faz,ffl
 ftc=
 fac=
 fmn=
 ftr=
 fyaw=
 flv
 fnv
 fgt=
 fsb=
 fhud,fearn,fbal,fconn
 fcs={}

 jsfx={
	Land=,Jumping=,Landing=,FreeFalling=,Running=,
	GettingUp=,Climbing=,Splash=,Swimming=,
}

  ()
	 ls=lp:()
	 b=ls  ls:()
	 (b  (b.Value))  


  ()
	 fconn  fconn:() fconn= 
	 fhud  fhud:() fhud= 
	fearn,fbal=,


  ()
	  fearn   fbal   
	 cur=()
	 earned=.(,cur-fsb)
	fearn.Text=..(earned)
	fbal.Text=..(cur)


  ()
	()
	fsb=()
	 pg=lp:()
	  pg   
	 gui=.()
	gui.Name=
	gui.ResetOnSpawn=
	gui.IgnoreGuiInset=
	gui.ZIndexBehavior=.ZIndexBehavior.Sibling
	gui.DisplayOrder=
	gui.Parent=pg
	 row=.()
	row.Name=
	row.AnchorPoint=.(,)
	row.Position=.(,)
	row.Size=.(,)
	row.BackgroundTransparency=
	row.Parent=gui
	 lay=.(,row)
	lay.FillDirection=.FillDirection.Horizontal
	lay.HorizontalAlignment=.HorizontalAlignment.Center
	lay.VerticalAlignment=.VerticalAlignment.Center
	lay.Padding=.(,)
	lay.SortOrder=.SortOrder.LayoutOrder
	  (txt,sz,col,ord,w)
		 t=.()
		t.BackgroundTransparency=
		t.Size=.(w,)
		t.FontFace=Font.(,.FontWeight.ExtraBold)
		t.TextSize=sz
		t.TextColor3=col
		t.Text=txt
		t.TextXAlignment=.TextXAlignment.Left
		t.LayoutOrder=ord
		t.Parent=row
		 s=.(,t)
		s.Thickness=
		s.Color=.(,,)
		s.Transparency=
		 t
	
	 icon=.()
	icon.BackgroundTransparency=
	icon.Size=.(,)
	icon.Image=
	icon.ScaleType=.ScaleType.Fit
	icon.LayoutOrder=
	icon.Parent=row
	fearn=(,,.(,,),,)
	fbal=(,,.(,,),,)
	fhud=gui
	()
	 ls=lp:()
	 b=ls  ls:()
	 b 
		fconn=b:():(tickh)
	


  ()
	 a=rs:()
	 c=a  a:()
	 r=c  c:()
	 n=r  r:()
	  n   
	 _,nm  ({,,}) 
		 s=n:(nm)
		 s  s:() 
			 nm==  fnv==  fnv=s.Volume 
			s.Volume=
			(() s:() )
		
	


  ()
	 a=rs:()
	 c=a  a:()
	 r=c  c:()
	 n=r  r:()
	 s=n  n:()
	 s  s:() 
		s.Volume=fnv  
	
	fnv=


  (ch)
	 ss=:()
	 mov=ss:()
	 land=mov  mov:()
	 land  land:() 
		 flv==  flv=land.Volume 
		land.Volume=
		(() land:() )
	
	  ch   
	 _,s  (ch:()) 
		 s:()  jsfx[s.Name] 
			 fcs[s]==  fcs[s]=s.Volume 
			s.Volume=
			(() s:() )
		
	


  (ch)
	 ss=:()
	 mov=ss:()
	 land=mov  mov:()
	 land  land:() 
		land.Volume=flv  
	
	 s,vol  (fcs) 
		 s  s.Parent 
			s.Volume=vol
		
	
	fcs={}
	flv=
	 ch 
		 _,s  (ch:()) 
			 s:()  jsfx[s.Name]  s.Volume== 
				s.Volume=
			
		
	


  ()
	 ch=lp.Character
	  ch   
	 hum=ch:()
	 hrp=ch:()
	  hum   hrp  hum.Health<=   
	 hum,hrp,ch


  ()
	 a=rs:()
	 r=a  a:()
	 p=r  r:()
	 p  p:()


  (ch)
	  ch   
	 _,d  (ch:()) 
		 d:() 
			 n=.(d.Name)
			 n:()  n:() 
				d.Disabled=
			
		 d:()  (d.Name==  d.Name==) 
			d.MaxForce=.()
			d.Velocity=.()
		
	
	 hum=ch:()
	 hum 
		(()
			hum:(.HumanoidStateType.Landed,)
			hum:(.HumanoidStateType.Jumping,)
			hum:(.HumanoidStateType.Freefall,)
			hum:(.HumanoidStateType.Running,)
		)
	


  (part)
	 top=(part.CFrame*.(,part.Size.Y*,)).Position
	 .(top.X,top.Y+,top.Z),top.Y


  (a,b)
	 dx,dz=a.X-b.X,a.Z-b.Z
	 .(dx*dx+dz*dz)


  ()
	 list={}
	 seen={}
	  (pos,floory)
		 floory<-  floory>   
		 key=.(pos.X+)....math.(pos.Z+)
		 seen[key]   
		seen[key]=
		list[#list+]={pos=pos,floor=floory}
	
	  (part)
		  part   part:()   
		 pos,floory=(part)
		(pos,floory)
	
	 sys=:()
	 map=sys  sys:()
	 sps=map  map:()
	 sps 
		 _,c  (sps:()) 
			 c:()  c:()  (c) 
		
	
	(:())
	 #list>  map 
		 offs={
			.(,,),
			.(-,,),
			.(,,-),
			.(-,,),
			.(,,),
		}
		 rp=RaycastParams.()
		rp.FilterType=.RaycastFilterType.Exclude
		 ignore={lp.Character}
		 _,nm  ({,,}) 
			 f=:(nm)
			 f  ignore[#ignore+]=f 
		
		rp.FilterDescendantsInstances=ignore
		 i=, 
			 src=list[((i-)%#list)+]
			 hint=.(src.pos.X+offs[i].X,src.pos.Y+,src.pos.Z+offs[i].Z)
			 hit=:(hint,.(,-,),rp)
			 hit  hit.Normal.Y>  hit.Instance:(map) 
				 floory=hit.Position.Y
				 floory>-  floory< 
					(.(hint.X,floory+,hint.Z),floory)
				
			
		
	
	 #list<  map 
		 floors=map:()
		 floors 
			 _,c  (floors:()) 
				 c:()  (c) 
			
		
	
	 list


  ()
	 t={}
	 _,nm  ({,}) 
		 f=:(nm)
		 f 
			 _,c  (f:()) 
				 r=(c)
				 r  t[#t+]=r.Position 
			
		
	
	 _,pl  (plrs:()) 
		 pl~=lp  pl.Character 
			 r=(pl.Character)
			 r  t[#t+]=r.Position 
		
	
	 t


  (relocate)
	 spots=()
	 #spots<   
	 threats=()
	 cur=fax  .(fax,,faz)
	 best,bests
	 _,s  (spots) 
		 relocate  cur  (s.pos,cur)< 
			
		
		 mint=
		 _,th  (threats) 
			 d=(s.pos,th)
			 d<mint  mint=d 
		
		 #threats<  mint= 
		  bests  mint>bests 
			bests=mint
			best=s
		
	
	  best  relocate 
		 _,s  (spots) 
			  cur  (s.pos,cur)>= 
				best=s
				
			
		
	
	 best


  (spot)
	fax,faz,ffl=spot.pos.X,spot.pos.Z,spot.floor
	 hum,hrp=()
	  hrp   
	 pos=spot.pos
	hrp.CFrame=.(pos,pos+.(,,-),.yAxis)
	hrp.AssemblyLinearVelocity=.()
	hrp.AssemblyAngularVelocity=.()
	fcd=


  ()
	  fax    
	 here=.(fax,,faz)
	 _,th  (()) 
		 (here,th)<=ftr    
	
	 


  (hum,hrp,ch)
	 hum.FloorMaterial~=.Material.Air    
	 st=hum:()
	 st==.HumanoidStateType.Running  st==.HumanoidStateType.Landed  st==.HumanoidStateType.Climbing 
		 
	
	 rp=RaycastParams.()
	rp.FilterType=.RaycastFilterType.Exclude
	rp.FilterDescendantsInstances={ch}
	 hit=:(hrp.Position,.(,-,),rp)
	 hit~=  hit.Normal.Y>


  ()
	 hum,hrp,ch=()
	  hum  (,)   
	 spot=()
	  spot  (,)   
	fret=hrp.CFrame
	fws=hum.WalkSpeed
	fjh=hum.JumpHeight
	fjp=hum.JumpPower
	fuj=hum.UseJumpPower
	(ch)
	hum.WalkSpeed=
	hum.AutoRotate=
	hum.PlatformStand=
	fgt=
	(()
		hum.Sit=
		hum.UseJumpPower=
		hum.JumpPower=
		hum.JumpHeight=
	)
	(spot)
	ftc=
	fyaw=
	(ch)
	()
	()
	fon=
	 


  (hum,ch)
	  hum   
	(()
		hum.UseJumpPower=fuj==
		hum.JumpPower=fjp  
		 attr=ch  ch:()
		 (attr)== 
			hum.JumpHeight=attr
		
			hum.JumpHeight=fjh  
		
	)


  ()
	fon=
	()
	 hum,hrp,ch=()
	 hum 
		hum.WalkSpeed=fws  
		hum.AutoRotate=
		hum.PlatformStand=
		(hum,ch)
	
	(ch  (lp.Character))
	()
	 hrp  fret 
		hrp.AssemblyLinearVelocity=.()
		hrp.AssemblyAngularVelocity=.()
		 p=fret.Position
		 look=fret.LookVector
		 f=.(look.X,,look.Z)
		 f.Magnitude<  f=.(,,-)  f=f.Unit 
		hrp.CFrame=.(p,p+f,.yAxis)
	
	fret=
	fax,faz,ffl=,,
	fuj=


lp.CharacterAdded:((ch)
	.()
	 fon  (ch) 
)

  (ch,on)
	  ch   
	 _,p  (ch:()) 
		 p:() 
			p.CanCollide= on
		
	


uis.JumpRequest:(()
	  inf  fon   
	 hum=()
	  hum   
	(()
		hum:(.HumanoidStateType.Jumping)
		hum.Jump=
	)
)

run.Heartbeat:((dt)
	 fon   
	 hum,hrp,ch=()
	  hum   
	 clip 
		(ch,)
		hrp.AssemblyAngularVelocity=.()
	
	 wson 
		 md=hum.MoveDirection
		 md.Magnitude> 
			 step=md.Unit*(wsval*dt)
			hrp.CFrame=hrp.CFrame+step
		
		hum.WalkSpeed=wsval
	
)

run.Heartbeat:((dt)
	  fon   
	 hum,hrp,ch=()
	  hum   fax   
	hum.WalkSpeed=
	hum.AutoRotate=
	hum.PlatformStand=
	(()
		hum.Sit=
		hum:(.HumanoidStateType.Landed,)
		hum:(.HumanoidStateType.Jumping,)
	)
	fcd=.(,fcd-dt)
	ftc=.(,ftc-dt)
	fac=.(,fac-dt)
	fmn=.(,fmn-dt)
	 fac<= 
		fac=
		(ch)
		(ch)
		()
	
	 ftc<= 
		ftc=
		 () 
			 nxt=()
			 nxt 
				(nxt)
				 fmn<= 
					fmn=
					(,)
				
			
		
	
	  (x,y,z,dir)
		 p=.(x,y,z)
		 f=.(dir.X,,dir.Z)
		 f.Magnitude<  f=.(,,-)  f=f.Unit 
		 .(p,p+f,.yAxis)
	
	 ffl  hrp.Position.Y<ffl- 
		hrp.CFrame=(fax,ffl+,faz,.(,,-))
		hrp.AssemblyLinearVelocity=.()
		hrp.AssemblyAngularVelocity=.()
		fcd=
		
	
	 grounded=(hum,hrp,ch)
	 y=hrp.AssemblyLinearVelocity.Y
	 d=fdir
	hum.Jump=
	(()
		hum.UseJumpPower=
		hum.JumpPower=
	)
	 grounded 
		fgt=fgt+dt
		 hop=fhop
		 fgt> 
			hop=fhop+
			fgt=
		
		 mxh=.(.(,*-hop*hop))
		 spd=.(fspd,mxh)
		y=hop
		(()
			hum:(.HumanoidStateType.Jumping)
		)
		 fcd<= 
			fcd=
			 re=()
			 re  (() re:() ) 
		
		hrp.AssemblyAngularVelocity=.()
		hrp.CFrame=(fax,hrp.Position.Y,faz,d)
		hrp.AssemblyLinearVelocity=.(d.X*spd,y,d.Z*spd)
		()
		
	
	fgt=
	 y< 
		y=ffall
	
	hrp.AssemblyAngularVelocity=.()
	hrp.CFrame=(fax,hrp.Position.Y,faz,d)
	hrp.AssemblyLinearVelocity=.(d.X*fspd,y,d.Z*fspd)
	()
)

.(()
	  
		 land   fon 
			 ch=lp.Character
			 hum=ch  ch:()
			 hrp=ch  ch:()
			 hum  hrp  hum.Health> 
				(() hum:(.HumanoidStateType.Freefall) )
				(() hum:(.HumanoidStateType.Landed) )
				 v=hrp.AssemblyLinearVelocity
				hrp.AssemblyLinearVelocity=.(v.X,,v.Z)
			
			.()
		 aud   fon 
			 re=()
			 re 
				(() re:() )
				(() re:() )
			
			.()
		
			.()
		
	
)

.(()
	  
		.()
		  unlk   
		 em=lp:()
		em=em  em:()
		 folder=rs:()
		folder=folder  folder:()
		  em   folder   
		 _,c  (folder:()) 
			  em:(c.Name) 
				 v=.()
				v.Name=c.Name
				v.Parent=em
			
		
	
)

 main=win:(,)
main:()
main:({Name=,CurrentValue=,Flag=,Callback=(v)
	kon=v
	 v 
		()
		 pon  () 
		(,)
	
		(kbag)
		 pon  () 
		(,)
	
})
main:({Name=,CurrentValue=,Flag=,Callback=(v)
	pon=v
	 v 
		()
		(,)
	
		(pbag)
		(,)
	
})

main:()
  ()
	 main.CreateDivider 
		(() main:() )
	
		(() main:({Title=,Content=}) )
	

main:({Name=,CurrentValue=,Flag=,Callback=(v)
	wson=v
	  v 
		 hum=()
		 hum   fon  hum.WalkSpeed= 
	
	(v    ,)
})
main:({Name=,Range={,},Increment=,CurrentValue=,Flag=,Callback=(v)
	wsval=v
})
main:({Name=,CurrentValue=,Flag=,Callback=(v)
	inf=v
	(v    ,)
})
main:({Name=,CurrentValue=,Flag=,Callback=(v)
	clip=v
	 _,_,ch=()
	 ch  (ch,v) 
	(v    ,)
})
()
 jtg,audtg
 ftg=main:({Name=,CurrentValue=,Flag=,Callback=(v)
	 v 
		 () 
			land=
			aud=
			.(()
				 jtg  jtg:() 
				 audtg  audtg:() 
			)
			(,)
		
			.(()
				 ftg  ftg:() 
			)
		
	
		()
		(,)
	
})
()
jtg=main:({Name=,CurrentValue=,Flag=,Callback=(v)
	 v  fon 
		land=
		.(()
			 jtg  jtg:() 
		)
		(,)
		
	
	land=v
	(v    ,)
})
audtg=main:({Name=,CurrentValue=,Flag=,Callback=(v)
	 v  fon 
		aud=
		.(()
			 audtg  audtg:() 
		)
		(,)
		
	
	aud=v
	(v    ,)
})
main:({Name=,Callback=()
	unlk=
	 em=lp:()
	em=em  em:()
	 folder=rs:()
	folder=folder  folder:()
	  em   folder  (,)  
	 _,c  (folder:()) 
		  em:(c.Name) 
			 v=.()
			v.Name=c.Name
			v.Parent=em
		
	
	(,)
})