Solinium V3point5 Lite

 Settings = {
    Prefix = ,
    AutoCommands = {}, 
    WhitelistedPlayers = {}, 
    BlacklistedGear = {}, 
    Debug = , 
    BannedPlayers = {}, 
    Disable3DRendering = 
}
 Settings.Disable3DRendering 
    :():()

 Variables = {}
 Characters = {,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,}
 Functions = {}
 RemovedObjects = {}
 Connections = {}
 Handler = {}
 Commands = {}
 Aliases = {}


 Functions:(Length)
     String = 
     i =  , Length 
        String ..= Characters[.(, #Characters)]
    
     String


 Functions:(String)
     .Players.LocalPlayer.PlayerGui:()  .Players.LocalPlayer.PlayerGui:():()  .Players.LocalPlayer.PlayerGui:():().Visible ==  
        .ReplicatedStorage.DefaultChatSystemChatEvents.SayMessageRequest:(String, )
    
        :():():():(String)
    


 Functions:(TitleText, MessageText, DurationSeconds)
    .StarterGui:(, {Title = TitleText, Text = MessageText, Duration = DurationSeconds})


 Handler:(Table1, Table2)
     Arguments = {}
     i,v  Table1 
         .(v, , ) .. .(v, -) ==  
            .(Arguments, {v,})
        
            .(Arguments, {v,})
        
    
     i,v  Arguments 
          Table2[i]  v[] ==  
            Functions:(, ..(i), )
             
        
    
     


 Functions:(Item)
     IsItemClassAllowed = (Item:    Item: )  (Item:    Item: )  Item:   Item:   Item:   Item:   Item:   Item:   Item:   Item: 
      IsItemClassAllowed   Item:() 
         
    
     


 Handler:(Name, CommandTable, Function)
    Commands[.(Name)] = {CommandTable, Function}
      CommandTable.Arguments 
        CommandTable.Arguments = {}
    
     CommandTable.Aliases  #CommandTable.Aliases >  
         i,v  CommandTable.Aliases 
            Aliases[.(v)] = Name
        
    
      CommandTable.Description 
        CommandTable.Description = 
    


 Handler:(CommandName, Arguments, FullString)
     Command = Commands[CommandName]  Commands[Aliases[CommandName]]
      Command 
        Functions:(, , )
        
    
     ArgumentsApproved = Handler:(Command[].Args, Arguments)
     ArgumentsApproved 
        Command[](Arguments, FullString)
    


 (tbl) 
	 tool
	tool = .Players.LocalPlayer.Backpack:()  (.Players.LocalPlayer.Character  .Players.LocalPlayer.Character:())
	  tool 
		Functions:()
		tool = .Players.LocalPlayer.Backpack:(, )
	
	(tool, )
	 SyncAPI = tool:(, )
	(SyncAPI, )
	 ServerEndpoint = SyncAPI:(, )
	(ServerEndpoint, )
	 tbl 
		 ServerEndpoint:((tbl))
	


 Functions:(instance, name)
     tbl = {}
     i,v  instance:() 
         v.Name == name 
            .(tbl, v)
        
    
     tbl


 Functions:(instance, classname)
     tbl = {}
     i,v  instance:() 
         v:(classname) 
            .(tbl, v)
        
    
     tbl


 (str)
	 str  (str) ==   str ~=  
		 players = .Players:()
		 str:() ==  
			 players
		 str:() ==  
			.(players, .(players, .Players.LocalPlayer))
			 players
		 str:() ==  
			 {.Players.LocalPlayer}
		 str:() ==  
			 i, v  players 
				  v:(.Players.LocalPlayer.UserId) 
					.(players, i)
				
			
			 players
         str:() ==  
            .(players, .(players, .Players.LocalPlayer))
             i, v  players 
				 v:(.Players.LocalPlayer.UserId) 
					.(players, i)
				
			
			 players
         str:() ==  
             {players[.(, #players)]}
		
			players = {}
			 i, v  .Players:() 
				 v.Name:():(, str:()) == str:()  v.DisplayName:():(, str:()) == str:() 
					.(players, v)
				
			
			 players
		
	
		 {}
	


 Functions:(instance, classname, timeout)
     i,v  instance:() 
         v:(classname) 
             v
        
    
     start = .()
     found
     connection
    connection = instance.ChildAdded:((child)
         child:(classname) 
            found = child
        
    )
      found 
         timeout  (.() - start) >= timeout 
            connection:()
             
        
        .()
    
    connection:()
     found




Handler:(, {Args = {}, Aliases = {}, Description = }, (Arguments, FullString)
     Str = 
     i,v  Commands 
        Str ..= Settings.Prefix..i....v[].Description....table.(v[].Args, )....table.(v[].Aliases, )..
    
    (Str)
    Functions:(, , )
)

Handler:(, {Args = {}, Aliases = {}, Description = }, (Arguments, FullString)
    Variables.AntiKick = 
     i,Object  :() 
         Object:() 
            Object.CanTouch = 
        
    
)

Handler:(, {Args = {}, Aliases = {}, Description = }, (Arguments, FullString)
    Variables.AntiKick = 
     i,v  :() 
         v:() 
            v.CanTouch = 
        
    
)

Handler:(, {Args = {}, Aliases = {}, Description = }, (Arguments, FullString)
     Variables.SKickFolder  Variables.SKickFolder.Parent == .Terrain  Variables.SKickFolder:() 
        Functions:(, , )
        
    
     ToBeRemoved = {}
     i,v  :() 
         v.Name ==  
            .(ToBeRemoved, v)
        
    
    ({, ToBeRemoved})
    Functions:()
     SkateboardTool = .Players.LocalPlayer.Backpack:(, )
      SkateboardTool 
        Functions:(, , )
        
    
    SkateboardTool.Parent = .Players.LocalPlayer.Character
    SkateboardTool:()
     SkateboardModel = :(, )
      SkateboardModel 
        Functions:(, , )
        
    
     SkateboardPlatform = SkateboardModel:(, )
      SkateboardPlatform 
        Functions:(, , )
        
    
    .(()
        ({, {SkateboardPlatform}, Functions:(.(, ))})
    )
    ({, {SkateboardPlatform:()}})
    ({, {{Part = SkateboardPlatform, Transparency = }}})
     SkateboardPlatform.Anchored ==  
        SkateboardPlatform:():()
    
    ({, {{Part = SkateboardPlatform, Anchored = }}})
    ({, {{Part = SkateboardPlatform,  = .(, -, ), Size = .(,,)}}})
    Variables.SKickFolder = ({, , .Terrain, {}})
    .(()
        ({, {Variables.SKickFolder}, Functions:(.(,))})
    )
     TemporaryFolder = ({, , Variables.SKickFolder, {SkateboardPlatform}})
     .()  TemporaryFolder  SkateboardPlatform.Parent == TemporaryFolder
    ({, {TemporaryFolder}})
    ({, {SkateboardModel}})
     .()  SkateboardPlatform.Parent == Variables.SKickFolder
    Functions:()
    Functions:(, , )
)

Handler:(, {Args = {}, Aliases = {,,}, Description = }, (Arguments, FullString)
      Variables.SKickFolder  Variables.SKickFolder.Parent ~= .Terrain   Variables.SKickFolder:() 
        Functions:(, , )
        
    
     i,v  (Arguments[]) 
        .(()
             kicktime = .()
             SkateboardPlatform = Variables.SKickFolder:()
            .(()
                ({, {SkateboardPlatform}, v.Character})
            )
            SkateboardPlatform = Functions:(v.Character, )
             OriginalCFrame = SkateboardPlatform.CFrame
            ({, {{Part = SkateboardPlatform,  = .(.(, ),.(, ),.(, )), Size = .(, , )}}})
             .()  SkateboardPlatform.CFrame ~= OriginalCFrame
             Timer
            .(, ()
                Timer = 
            )
             SkateboardCFrame = SkateboardPlatform.CFrame
             FormattedCFrame = SkateboardCFrame * .(, ((v.Character.Torso.Size.Y/) + (v.Character.Head.Size.Y/)), )
            
                 v.Character  v.Character.HumanoidRootPart  v.Character.Torso  v.Character.Head 
                    .(()
                        ({, {{Part = v.Character.HumanoidRootPart,  = SkateboardCFrame}, {Part = v.Character.Torso,  = SkateboardCFrame}, {Part = v.Character.Head,  = FormattedCFrame}, {Pivot = FormattedCFrame, Model = v.Character}}})
                    )
                
                .()
              .(.Players:(), v)  Timer
             Timer 
                ()
                ({, {SkateboardPlatform, v.Character}})
            
                 FinalTime = (.((.() - kicktime) * ))
                (..v.DisplayName....FinalTime..)
                Functions:(..v.DisplayName, FinalTime.., )
                ({, {SkateboardPlatform, v.Character}})
            
        )
    
)

Handler:(, {Args = {}, Aliases = {}, Description = }, (Arguments, FullString)
     i,v  (Arguments[]) 
        .(Settings.BannedPlayers, v.UserId)
        Commands[][]({v.Name})
    
)

Handler:(, {Args = {}, Aliases = {}, Description = }, (Arguments, FullString)
     (Arguments[]) ~=    .(Settings.BannedPlayers, (Arguments[])) 
        .(Settings.BannedPlayers, (Arguments[]))
         i,v  .Players:() 
             v.UserId == (Arguments[]) 
                Commands[][]({v.Name})
                
            
        
    
)

Handler:(, {Args = {}, Aliases = {}, Description = }, (Arguments, FullString)
     UserId = (Arguments[])
     .(Settings.BannedPlayers, UserId) 
        .(Settings.BannedPlayers, .(Settings.BannedPlayers, UserId))
         Success, Username = (()
             .Players:(UserId)
        )
         Success 
            Functions:(, ..Username, )
        
    
        Functions:(, , )
    
)

Handler:(, {Args = {}, Aliases = {}, Description = }, (Arguments, FullString)
     Str = 
     i,v  Settings.BannedPlayers 
        Str ..= (v)..
    
    (Str)
)

Handler:(, {Args = {}, Aliases = {}, Description = }, (Arguments, FullString)
    Settings.BannedPlayers = {}
)

Handler:(, {Args = {}, Aliases = {}, Description = }, (Arguments, FullString)
     Option
      Arguments[] 
        
     .(, , .(Arguments[])) == Arguments[]:() 
        Option = 
    
        
    
    Variables.ServerLock = Option
    Functions:(, ..Option, )
)

Handler:(, {Args = {}, Aliases = {}, Description = }, (Arguments, FullString)
    Variables.ServerLock = 
    Functions:(,, )
)

Handler:(, {Args = {}, Aliases = {,}, Description = }, (Arguments, FullString)
      Variables.PKS 
        
    
     i,v  (Arguments[]) 
        ({, {{Part = v.Character:(), Anchored = }}})
        Functions:(..v.Name)
        Functions:(..v.Name..)
         Tool = Variables.PKS:()
          Tool 
            ()
            
        
        ({, {Tool}, })
         .()  (v.Character.Head.Position - v.Character.HumanoidRootPart.Position).Magnitude < 
        ({, .(, Tool), v.Character})
        ({, {Tool}, Functions:(.(,))})
    
)

Handler:(, {Args = {}, Aliases = {}, Description = }, (Arguments, FullString)
     Variables.PKS 
        
    
     TempPart = ({, , .(,,), .Terrain})
    ({, {{Part = TempPart, LightType = }}})
    ({, {{Part = TempPart, LightType = , Brightness = }}})
    Variables.PKS = TempPart:()
    ({, {Variables.PKS}, Functions:(.(,))})
    ({, {TempPart}})
    Functions:()
     Tool = .Players.LocalPlayer.Backpack:()
    Tool.Parent = .Players.LocalPlayer.Character
    ({, {Tool}, Variables.PKS})
    ({, {Tool}, Functions:(.(,))})
)


.(()
    Connections[#Connections + ] = .TextChatService.SendingMessage:((Message)
        Message = Message.Text
         .(Message, , .(Settings.Prefix)) == Settings.Prefix 
            Message = .(Message, .(Settings.Prefix) + )
             Arguments = {}
             i  .(Message, ) 
                .(Arguments, i)
            
            .(()
                Handler:(Arguments[], {.(Arguments, )}, Message)
            )
        
    )
)

.(()
    Connections[#Connections + ] = .DescendantAdded:((Object)
         Object:()  Variables.AntiKick 
            Object.CanTouch = 
        
    )
)

.(()
    Connections[#Connections + ] = .Players.LocalPlayer.PlayerGui.ChildAdded:((Object)
         Object:()  Object.Name ==  
            Object.Enabled = 
            .Debris:(Object,)
            ()
        
    )
)

.(()
    Connections[#Connections + ] = .Players.PlayerAdded:((Player)
        (..Player.DisplayName....Player.Name....Player.UserId)
         Variables.ServerLock  Variables.ServerLock ==  
            Player.CharacterAdded:()
             .()  Player.Character:()  Player.Character:()  Player.Character:()
            Commands[][]({Player.Name})
         .(Settings.BannedPlayers, Player.UserId) 
            Player.CharacterAdded:()
             .()  Player.Character:()  Player.Character:()  Player.Character:()
            Commands[][]({Player.Name})
        
    )
)

.(()
    Connections[#Connections + ] = .Players.PlayerRemoving:((Player)
        (..Player.DisplayName....Player.Name....Player.UserId)
    )
)

.(()
     i,Message  Settings.AutoCommands 
        .(()
             Arguments = {}
             i  .(Message, ) 
                .(Arguments, i)
            
            .(()
                Handler:(Arguments[], {.(Arguments, )}, Message)
                (..Message..)
            )
        )
    
)


.(()
     ScreenGui = .()
	 Frame = .()
	 Frame_2 = .()
	 TextBox = .()
	 UIStroke = .()
	 enabled;

	ScreenGui.Parent = .CoreGui
	ScreenGui.ZIndexBehavior = .ZIndexBehavior.Sibling
	ScreenGui.DisplayOrder = 
	ScreenGui.IgnoreGuiInset = 
	ScreenGui.ResetOnSpawn = 

	Frame.Parent = ScreenGui
	Frame.BackgroundColor3 = .(, , )
	Frame.BackgroundTransparency = 
	Frame.BorderColor3 = .(, , )
	Frame.BorderSizePixel = 
	Frame.Transparency = 
	Frame.Size = .(, , , )

	Frame_2.Parent = Frame
	Frame_2.BackgroundColor3 = .(, , )
	Frame_2.BackgroundTransparency = 
	Frame_2.BorderColor3 = .(, , )
	Frame_2.BorderSizePixel = 
	Frame_2.Position = .(-, , , )
	Frame_2.Transparency = 
	Frame_2.Size = .(, , , )

	UIStroke.Parent = Frame_2
	UIStroke.ApplyStrokeMode = .ApplyStrokeMode.Border
	UIStroke.LineJoinMode = .LineJoinMode.Round
	UIStroke.Thickness = 
	UIStroke.Color = .(, , )

	TextBox.Parent = Frame_2
	TextBox.BackgroundColor3 = .(, , )
	TextBox.BackgroundTransparency = 
	TextBox.BorderColor3 = .(, , )
	TextBox.BorderSizePixel = 
	TextBox.Position = .(, , , )
	TextBox.Size = .(, , , )
	TextBox.Transparency = 
	TextBox.TextTransparency = 
	TextBox.Font = .Font.SourceSans
	TextBox.PlaceholderColor3 = .(, , )
	TextBox.PlaceholderText = 
	TextBox.Text = 
	TextBox.TextColor3 = .(, , )
	TextBox.TextSize = 
	TextBox.TextXAlignment = .TextXAlignment.Left
	.()
	Frame_2:(.(-, , -, ), , , )
	enabled = 
	TextBox.Focused:(()
		TextBox.Text = 
		enabled = 
		Frame_2.Position = .(-, , , )
	)
	TextBox.FocusLost:(()
		 TextBox.Text ~=  
             .(TextBox.Text, , .(Settings.Prefix)) == Settings.Prefix 
                 Message = .(TextBox.Text, .(Settings.Prefix) + )
                 Arguments = {}
                 i  .(Message, ) 
                    .(Arguments, i)
                
                .(()
                    Handler:(Arguments[], {.(Arguments, )}, Message)
                )
            
                Functions:(TextBox.Text)
            
			TextBox.Text = 
		
		enabled = 
		Frame_2.Position = .(-, , -, )
	)
	:().InputEnded:((key, gpe)
		 key.KeyCode == .KeyCode.Semicolon   gpe 
			  enabled 
				TextBox:()
			
		
	)
)