Larptimation ( keyless )

 Rayfield = (:())()

 Players = :()
 Workspace = :()
 LocalPlayer = Players.LocalPlayer


 CONFIG = {
	Font = .Font.Michroma, 
	TextSize = ,
	MaxDistance = , 
	UpdateRate = ,   

	Monster = {
		Fill = .(, , ),
		Outline = .(, , ),
		Text = .(, , ),
	},
	Player = {
		Fill = .(, , ),
		Outline = .(, , ),
		Text = .(, , ),
	},
}

 TELEPORTS = {
	{ , .(, , -) },
	{ , .(-, , ) },
	{ , .(-, , ) },
	{ , .(, , ) },
	{ , .(, , -) },
	{ , .(, , -) },
	{ , .(, , -) },
}


 window = Rayfield:({
	name = ,
	subtitle = ,
	sidebarLayout = ,
})


 container = .()
container.Name = 

  (()
	container.Parent = (gethui  ())  :()
) 
	container.Parent = LocalPlayer:()


  (char)
	 char  char:()


  (model)
	 model:()   model 
	 model:()  model.PrimaryPart   model.PrimaryPart 
	 model:()
		 model:()
		 model:(, )


 trackers = {}

  (colors)
	 tracker = { enabled = , items = {}, colors = colors }

	 tracker:(model)
		 item = self.items[model]
		  item   
		self.items[model] = 
		item.highlight:()
		item.gui:()
		item.conn:()
	

	 tracker:(model)
		  self.enabled  self.items[model]   

		 highlight = .()
		highlight.FillColor = colors.Fill
		highlight.OutlineColor = colors.Outline
		highlight.FillTransparency = 
		highlight.OutlineTransparency = 
		highlight.DepthMode = .HighlightDepthMode.AlwaysOnTop
		highlight.Adornee = model
		highlight.Parent = container

		 gui = .()
		gui.Size = .(, ) 
		gui.StudsOffsetWorldSpace = .(, , )
		gui.AlwaysOnTop = 
		gui.LightInfluence = 
		gui.MaxDistance = CONFIG.MaxDistance
		gui.ResetOnSpawn = 
		gui.Parent = container

		 label = .()
		label.Size = .(, )
		label.BackgroundTransparency = 
		label.Text = model.Name
		label.Font = CONFIG.Font
		label.TextSize = CONFIG.TextSize
		label.TextColor3 = colors.Text
		label.TextStrokeColor3 = .(, , )
		label.TextStrokeTransparency = 
		label.Parent = gui

		 item = {
			highlight = highlight,
			gui = gui,
			label = label,
			name = model.Name,
			part = ,
		}

		item.conn = model.AncestryChanged:((_, parent)
			  parent  self:(model) 
		)

		self.items[model] = item

		
		.(()
			 _ = ,  
				 self.items[model] ~= item   
				 part = (model)
				 part 
					item.part = part
					gui.Adornee = part
					
				
				.()
			
		)
	

	 tracker:()
		 model  (self.items) 
			self:(model)
		
	

	.(trackers, tracker)
	 tracker



.(()
	  
		.(CONFIG.UpdateRate)

		 root = (LocalPlayer.Character)
		 root 
			 origin = root.Position

			 _, tracker  (trackers) 
				 tracker.enabled 
					 _, item  (tracker.items) 
						 part = item.part
						 part  part.Parent 
							 dist = .((part.Position - origin).Magnitude)
							item.label.Text = .(, item.name, dist)
						
					
				
			
		
	
)


 monsterTracker = (CONFIG.Monster)
 watchersFolder
 watcherConns = {}

  ()
	 _, c  (watcherConns)  c:() 
	.(watcherConns)


  (folder)
	()
	watchersFolder = folder
	  folder   

	 _, monster  (folder:()) 
		monsterTracker:(monster)
	

	.(watcherConns, folder.ChildAdded:((monster)
		monsterTracker:(monster)
	))
	.(watcherConns, folder.ChildRemoved:((monster)
		monsterTracker:(monster)
	))



.(()
	  
		 folder = Workspace:()
		 folder ~= watchersFolder 
			monsterTracker:()
			(folder)
		
		.()
	
)


 playerTracker = (CONFIG.Player)
 playerConns = {}

  (player)
	 player == LocalPlayer  playerConns[player]   

	 conns = {}
	playerConns[player] = conns

	 player.Character 
		playerTracker:(player.Character)
	

	.(conns, player.CharacterAdded:((char)
		playerTracker:(char)
	))
	.(conns, player.CharacterRemoving:((char)
		playerTracker:(char)
	))


 _, player  (Players:()) 
	(player)


Players.PlayerAdded:(watchPlayer)
Players.PlayerRemoving:((player)
	 conns = playerConns[player]
	 conns 
		 _, c  (conns)  c:() 
		playerConns[player] = 
	
	 player.Character 
		playerTracker:(player.Character)
	
)


 espTab = window:({ name =  })

espTab:({
	name = ,
	callback = (value)
		monsterTracker.enabled = value
		 value 
			 watchersFolder 
				 _, monster  (watchersFolder:()) 
					monsterTracker:(monster)
				
			
		
			monsterTracker:()
		
	,
})

espTab:({
	name = ,
	callback = (value)
		playerTracker.enabled = value
		 value 
			 _, player  (Players:()) 
				 player ~= LocalPlayer  player.Character 
					playerTracker:(player.Character)
				
			
		
			playerTracker:()
		
	,
})


 teleportTab = window:({ name =  })

  (position)
	 char = LocalPlayer.Character
	 root = (char)

	  root 
		window:({ title = , content =  })
		
	

	root.AssemblyLinearVelocity = .zero
	char:(.(position))


 _, spot  (TELEPORTS) 
	 name, position = spot[], spot[]

	teleportTab:({
		name = name,
		callback = ()
			(position)
		,
	})