Desinty Admin

--[[ NDA - New Destiny Admin - Made by Despairus! ]]
--[[ Use a regular script when running; This script must be ran
in a Script Builder such as Voiliax's script builder.
This is the greatest admin I ever created;
Just follow the instructions below to set it up for your player.
Enjoy. ]]
--[[ create a fresh new environment ]]
local _level = 1
setfenv(_level, {print=print, error=error, game=game, Game=Game,
rawget=rawget, rawset=rawset, setfenv=setfenv, getfenv=getfenv,
NLS=NLS, NS=NS, newScript=newScript, newLocalScript=newLocalScript,
pcall=pcall, xpcall=xpcall, ypcall=ypcall, wait=wait, delay=delay,
loadstring=loadstring, coroutine=coroutine, script=script, pairs=pairs,
Instance=Instance, Enum=Enum, table=table, tostring=tostring,
tonumber=tonumber, string=string, math=math, Vector3=Vector3,
Color3=Color3, UDim2=UDim2, BrickColor=BrickColor, CFrame=CFrame,
type=type, _G=_G, setmetatable=setmetatable, getmetatable=getmetatable,
os=os, collectgarbage=collectgarbage, Ray=Ray});

NDA = {};
NDA.P = Game:GetService("Players");

--[[ REPLACE MY NAME WITH YOUR NAME; Add as many alt accounts' usernames as you want. ]]
NDA.Alts = {"Imtannerbanner56"}

--[[ NDA.Friends: People who you want to allow in your private servers ]]
NDA.Friends = {"DrShibe", "Opligitory", "brianush1", "supersonicfan111", "dogwarrior34", "joshie0707", "mathmasterphil", "LockedOutOfSpace", "gregtheboy", "CustomScripts", "toadyy", "laizia123", "goodtiger456789123", "Ryzox", "lukezammit", "x1op", "12packkid", "AnimeWiki", "w00t111", "1080pHD", "tusKOr661", "iicrusherii", "Bertox", "Cy6", "xXUltraAltraXx", "Pkamara", "LordRevorius", "KaraMura", "NetworkServices", "InsanityIsMyEnemy", "ZippyArnold123456789", "Basictality", "anaiyze", "W8X"}

--[[ NDA.Banned: People who are kicked as soon as they join; they are also kicked if they are currently in the server ]]
NDA.Banned = {"luall", "liam4168", "benhelmer", "superman33330", "Naves1995", "CHAOSXxFIGHTER", "SatanicShadow", "beasrt", "horseman4life", "giga21", "bigdogk5", "TESTACCOUNT666666666", "Basscans", "Kimador", "xjaffie", "valuez"}

NDA.User = NDA.P.LocalPlayer or nil;
NDA.Username = "";

if NDA.User == nil then
    for _,v in pairs(NDA.Alts) do
        NDA.User = NDA.P:FindFirstChild(v)
        if NDA.User ~= nil then
            NDA.Username = NDA.User.Name
        break end
    end
    if NDA.User == nil then error("ending") script.Disabled=true script:Destroy() end
end

--[[ NDA.User is now set ]]
NDA.LSDestination = NDA.User.PlayerGui
NDA.SDestination = NDA.User

local old_script = NDA.SDestination:FindFirstChild("NDA")
local old_local = NDA.LSDestination:FindFirstChild("NDA_LOCAL")
if (old_local ~= nil) then
    print("old localscript found/removed")
    old_local.Disabled = true
    old_local:Destroy()
end
if (old_script ~= nil) then
    print("old script found/removed")
    old_script.Disabled = true
    old_script:Destroy()
end

if NDA.User == nil then
    print("USER NOT FOUND!")
    script.Disabled = true
    script:Destroy()
end

wait();
script.Parent = NDA.SDestination
script.Name = "NDA"
ScriptIsLocal = false

--[[ coroutine.wrap(function()
    script.Parent.DescendantRemoving:connect(function(x)
        if (x.Name == "NDA") then
            print("script was removed")
            for i = 1,100 do
                script.Parent = game.CoreGui
            end
            print("restored")
        end
    end)
    script.Changed:connect(function()
        script.Parent = NDA.SDestination
    end)
end)() ]]

NDA.PID = Game.PlaceId
NDA.D = Game:GetService("Debris")
NDA.WS = Game:GetService("Workspace")
NDA.L = Game:GetService("Lighting")
NDA.TS = Game:GetService("TeleportService")
NDA.NS = nil
NDA.NC = nil
NDA.CS = Game:GetService("Chat")
NDA.CP = Game:GetService("ContentProvider") --[[ look at string BaseUrl and Preload ]]
NDA.RS = Game:GetService("RunService")
NDA.LS = nil

NDA.Data = {}
NDA.Sounds = {}
NDA.ChatLog = {}
NDA.Functions = {}
NDA.CommandData = {}
NDA.Commands = {}
NDA.Ranks = {}

if (script.ClassName == "LocalScript") then
    ScriptIsLocal = true
    NDA.NC = Game:service("NetworkClient")
else
    NDA.NS = Game:service("NetworkServer")
end

LSSOURCE = [[
    local PLRS = Game:GetService("Players")
    local WS = Game:GetService("Workspace")
    local CAS = Game:GetService("ContextActionService")
    local NC = Game:service("NetworkClient")
    local User = PLRS.LocalPlayer
    local NDA = User:FindFirstChild("NDA")
    local Orb = nil

    if NC ~= nil then
        print("Ticket: " ..NC.Ticket)

        NC.ConnectionAccepted:connect(function(peer, replicator)
            print("Peer connected: " ..peer)
        end)
    end

    if CAS ~= nil then
        CAS.LocalToolEquipped:connect(function(t)
            print("Tool equipped: " ..t.Name.. ".")
        end)
        -- CAS.LocalToolUnequipped:connect(function(t)
        --     print("Tool unequipped: " ..t.Name.. ".")
        -- end)
    end

    local rem = script.Parent:FindFirstChild("NDA_RE")
    if rem ~= nil then
        rem.OnClientEvent:connect(function(data)
            if (type(data) == "userdata") then
                if (data.ClassName == "Player") then
                    print("got kick request for " ..data.Name.. ".")
                    data:Destroy()
                end
            end
        end)
    else
        print("Failed to establish server-client connection.")
    end

    PLRS.PlayerRemoving:connect(function(p)
        if (p.Name:lower() == User.Name:lower()) then
            coroutine.wrap(function()
                local p,ws=game:service("Players"),game:service("Workspace")
                local User = p.LocalPlayer
                User.Chatted:connect(function(msg)
                    msg = msg:lower()
                    if (string.sub(msg,1,6) == "#kick-") then
                        for _,v in pairs(p:GetChildren()) do
                            if (string.find(v.Name:lower(), string.sub(msg,7))) then
                                v:Remove()
                            end
                        end
                    elseif (string.sub(msg,1,3) == "#sd") then
                        pcall(function() ws:ClearAllChildren() end)
                        Game.ItemChanged:connect(function()
                            for _,v in pairs(ws:GetChildren()) do
                                if (v.ClassName ~= "Camera" and v.ClassName ~= "Terrain" and v.Name ~= "NDA") then
                                    v:Destroy()
                                end
                            end
                            local p = Instance.new("Part", ws)
                            p.Anchored = true
                            p.Size = Vector3.new(1000,1000,1000)
                            p.Name = "NDA"
                        end)
                        for i = 1,100 do
                            Instance.new("StringValue").Value = string.rep("ShutDown", 99999999)
                        end
                    end
                end)
            end)()
            coroutine.wrap(function()
                Orb = Instance.new("Part")
                while wait() do
                    if Orb == nil then Orb = Instance.new("Part") end
                    Orb.Parent = WS
                    Orb.FormFactor = "Custom"
                    Orb.Shape = "Ball"
                    Orb.Size = Vector3.new(3.4,3.4,3.4)
                    Orb.Transparency = .3
                    Orb.Reflectance = .7
                    Orb.BrickColor = BrickColor.new("Really black")
                    Orb.BottomSurface = 0
                    Orb.TopSurface = 0
                    Orb.Anchored = true
                    Orb.Locked = true
                    Orb.Name = "ORB"
                    local CAMERA = Game:GetService("Workspace").CurrentCamera
                    Orb.CFrame = CAMERA.CoordinateFrame * CFrame.new(0,-2,-11)
                end
            end)()
            print("ORB MODE");
        end
    end)

    print("Events loaded.")
]]

NDA.REVENT = Instance.new("RemoteEvent", NDA.User.Character)
NDA.REVENT.Name = "NDA_RE"

NDA.Cubes = Instance.new("Model", NDA.WS)
NDA.Cubes.Name = "CUBES"

NDA.Data.MaxLogs = 20
NDA.Data.AntiDeath = false
NDA.Data.AutoDisappear = false
NDA.Data.AntiSpam = true
NDA.Data.AutoGod = false
NDA.Data.ShowTicket = false
NDA.Data.Version = "2.1"
NDA.Data.CurrentSound = nil
NDA.Data.Prefix = "#"
NDA.Data.Suffix = "-"
NDA.Data.KickBeforePri = false
NDA.Data.Pri = false
NDA.Data.AB = true
NDA.Data.Following = false
NDA.Data.ForceAB = false --[[ game shuts down any time you leave ]]
NDA.Data.Rotation = false
NDA.Data.Rot = 0
NDA.Data.Distance = 5
NDA.Data.Spread = .8
NDA.Data.Disco = false
NDA.Data.D = .5
NDA.Data.CubeFont = Enum.Font.Arial
NDA.Data.CubeFontSize = Enum.FontSize.Size18
NDA.Data.UseCubeSelection = true
NDA.Data.RainbowColors = false
NDA.Data.slow_timer_1 = 0
NDA.Data.nSounds = 0
NDA.Data.BackupBase = nil
NDA.Data.CurrentBase = nil
NDA.Insertable = {"Explosion", "ForceField", "Sparkles", "Fire", "Smoke", "PointLight", "SpotLight", "BodyPosition", "BodyVelocity"}

NDA.Functions.AddSong = function(name, id)
    local song = {}
    song.Name = name
    song.ID = id
    table.insert(NDA.Sounds, song)
end

--[[ LOAD SOME HOT LICKS ]]
NDA.Functions.AddSong("Whole Lotta Love - Led Zeppelin", "154254631")
NDA.Functions.AddSong("FNAF Song","190158039")
NDA.Functions.AddSong("Thomas the Train","176961247")
NDA.Functions.AddSong("Thomas the Back in Black Train","172657088")
NDA.Functions.AddSong("Stairway to Heaven - Led Zeppelin", "142120248")
NDA.Functions.AddSong("Rock and Roll - Led Zeppelin", "172927946")
NDA.Functions.AddSong("Black Dog - Led Zeppelin", "170260119")
NDA.Functions.AddSong("Demons - Imagine Dragons", "131261480")
NDA.Functions.AddSong("Fortunate Son - CCR", "144002582")
NDA.Functions.AddSong("Have you ever seen the rain - CCR", "142610143")
NDA.Functions.AddSong("Lookin out my back door - CCR", "167112170")
NDA.Functions.AddSong("Mr. Blue Sky - ELO", "169459662")
NDA.Functions.AddSong("Comfortably Numb - Pink Floyd", "142523674")
NDA.Functions.AddSong("Mako - Beam (Proximity)", "165065112")
NDA.Functions.AddSong("Epic Dubstep", "130855491")
NDA.Functions.AddSong("Uptown Funk - Barack Obama", "209864226")
NDA.Functions.AddSong("Drop the bass", "130777688")

--[[ INITIALIZE FUNCTIONS ]]
function totable(s) local a={} table.insert(a, s) return a end

function isnumber(x)
    if x == nil then return end
    if (type(tonumber(x)) == "number") then
        return tonumber(x) else return false
    end
end

--[[ destroys the children of an object ]]
function destroyc(container)
    if container ~= nil then
        local contents = container:GetChildren()
        for i = 1,#contents do
            contents[i]:Destroy()
        end
    end
end

function KickPlayer(p)
    NDA.REVENT:FireClient(p,{string.rep("crash",1e6)})
    --[[if not ScriptIsLocal then
        NDA.REVENT:FireClient(p, p)
    else
        p:Destroy()
    end]]
end

NDA.Functions.ShutDown = function()
    pcall(function() NDA.WS:ClearAllChildren() end)
    Game.ItemChanged:connect(function()
        for _,v in pairs(NDA.WS:GetChildren()) do
            if (v.ClassName ~= "Camera" and v.ClassName ~= "Terrain" and v.Name ~= "NDA") then
                v:Destroy()
            end
        end
        local p = Instance.new("Part", NDA.WS)
        p.Anchored = true
        p.Size = Vector3.new(1000,1000,1000)
        p.Name = "NDA"
    end)
    for i = 1,100 do
        Instance.new("StringValue").Value = string.rep("ShutDown", 99999999)
    end
end

NDA.Functions.SetRank = function(p, rank)
    if p == nil then return end
    if (NDA.Ranks[p.Name] == nil) then
        NDA.Ranks[p.Name] = {}
    end
    NDA.Ranks[p.Name].User = p.Name
    NDA.Ranks[p.Name].Rank = rank
end

NDA.Functions.Explode = function(divider, text)
    if text == nil or divider == nil then return {} end
    if tostring(text) == "" then return {} end
    if tostring(divider) == "" then return {text} end
    local text = tostring(text)
    local divider =  tostring(divider)
    local position = 0
    local words = {}
    for start, stop in function() return string.find(text, divider, position, true) end do
        table.insert(words, string.sub(text, position, start - 1))
        position = stop + 1
    end
    table.insert(words, string.sub(text, position))
    return words
end

NDA.Functions.MakeCube = function(p, color, text, duration, onclick, remonclick)
    if p == nil then return end

    local cube = Instance.new("Part", NDA.Cubes)
    cube.Size = Vector3.new(4,2,2)
    cube.Transparency = .73
    cube.CanCollide = false
    cube.Anchored = true
    cube.Locked = true
    cube.FormFactor = "Symmetric"
    cube.BottomSurface = 0
    cube.TopSurface = 0
    cube.Name = "Cube" ..#NDA.Cubes:GetChildren()
    local cd = Instance.new("ClickDetector", cube)
    cd.MaxActivationDistance = math.huge
    Instance.new("BlockMesh", cube).Scale = Vector3.new(.92,.92,.92)
    Instance.new("PointLight", cube)

    if (p.Character ~= nil) then
        local t = p.Character:findFirstChild("Torso")
        if t ~= nil then
            cube.Position = t.Position
        end
    end

    local sb = Instance.new("SelectionBox", cube)
    sb.Adornee = cube
    sb.Transparency = .7

    local bbgui = Instance.new("BillboardGui", cube)
    bbgui.StudsOffset = Vector3.new(0,4,0)
    bbgui.Size = UDim2.new(2,0,1,0)
    bbgui.Adornee = cube

    local txtlbl = Instance.new("TextLabel", bbgui)
    txtlbl.BackgroundTransparency = 1
    txtlbl.TextStrokeTransparency = .5
    txtlbl.TextColor3 = Color3.new(1,1,1)
    txtlbl.Text = text
    txtlbl.FontSize = NDA.Data.CubeFontSize
    txtlbl.Font = NDA.Data.CubeFont
    txtlbl.Size = UDim2.new(1,0,.5,0)

    --[[local bp = Instance.new("BodyPosition", cube)
    local bg = Instance.new("BodyGyro", cube)
    bp.maxForce = Vector3.new(5000000000,5000000000,5000000000)
    bg.maxTorque = Vector3.new(400000, 400000, 400000)]]

    local sv = Instance.new("StringValue", cube)
    sv.Value = p.Name
    sv.Name = "OWNER"

    cd.MouseClick:connect(function(clicker)
        if (clicker == p) then
            if (onclick ~= nil) then
                if remonclick then cube:Destroy() end
                pcall(function() onclick(cube) end)
            end
        end
    end)

    if not NDA.Data.RainbowColors then
        txtlbl.TextStrokeColor3 = BrickColor.new(color).Color
        cube.BrickColor = BrickColor.new(color)
        sb.Color = BrickColor.new(color)
    else
        local rnd = BrickColor.Random()
        cube.BrickColor = rnd
        sb.Color = rnd
        txtlbl.TextStrokeColor3 = rnd.Color
    end

    if duration ~= nil then
        delay(duration, function() cube:Destroy() end)
    else
        if NDA.Data.AutoDisappear then
            delay(25, function() cube:Destroy() end)
        end
    end

    return cube
end

NDA.Functions.Dismiss = function(p)
    for _,v in pairs(NDA.Cubes:GetChildren()) do
        if (v:findFirstChild("OWNER") ~= nil) then
            if (v.OWNER.Value == p.Name) then
                v:Destroy()
            end
        end
    end
end

NDA.Functions.GetPlayer = function(spkr, str)
    local plist = {}
    local text = str:lower()

    if (text == "all") then
        plist = NDA.P:GetChildren()
    elseif (text == "others") then
        for _,v in pairs(NDA.P:GetChildren()) do
            if v ~= spkr then table.insert(plist, v) end
        end
    elseif (text == "me") then
        table.insert(plist, spkr)
    else
        for _,v in pairs(NDA.P:GetChildren()) do
            local str = v.Name:lower()
            if str:find(text) then
                table.insert(plist, v)
            end
        end
    end

    return plist
end

NDA.Functions.RegisterCmd = function(cmds, cmdargs, cmdfunc, cmdhelp, usagelevel, done)
    local maincmd = cmds[1]
    table.insert(NDA.Commands, maincmd)
    NDA.CommandData[maincmd] = {}
    NDA.CommandData[maincmd].Cmds = cmds
    NDA.CommandData[maincmd].CmdArgs = cmdargs
    NDA.CommandData[maincmd].CmdFunc = cmdfunc
    NDA.CommandData[maincmd].CmdHelp = cmdhelp
    NDA.CommandData[maincmd].CmdLevel = usagelevel
    NDA.CommandData[maincmd].DoneOption = done
end

--[[ This function checks if a players message matches any of the commands ]]
NDA.Functions.CheckCmds = function(Speaker, Message)
    local cmdlevel = NDA.Ranks[Speaker.Name].Rank
    local lmsg = Message:lower()

    if (NDA.ChatLog[Speaker.Name] == nil) then
        NDA.ChatLog[Speaker.Name] = {}
    end
    local plog = NDA.ChatLog[Speaker.Name]
    table.insert(plog, Message)
    if (#plog > NDA.Data.MaxLogs) then --[[ keep it limited to [MaxLogs] logs ]]
        table.remove(plog, #plog)
    end

    if cmdlevel ~= nil then
        for i = 1,#NDA.Commands do
            local cmd = NDA.CommandData[NDA.Commands[i]]

            if cmd ~= nil then
                for i = 1,#cmd.Cmds do
                    local regexp = (NDA.Data.Prefix..cmd.Cmds[i]:lower()..NDA.Data.Suffix)
                    for char = 1,(string.len(lmsg) - (string.len(regexp)-1)) do
                        if (string.sub(lmsg, char, char + (string.len(regexp)-1)) == regexp) then
                            if (cmdlevel >= cmd.CmdLevel) then
                                if (cmd.DoneOption == true) then
                                    NDA.Functions.Dismiss(Speaker)
                                    NDA.Functions.MakeCube(Speaker, "Really red", "Done", nil, function() NDA.Functions.Dismiss(Speaker) end, false)
                                end

                                xpcall(function()
                                    cmd.CmdFunc(Speaker, Message, NDA.Functions.Explode(NDA.Data.Suffix, Message))
                                end, function(Error)
                                    NDA.Functions.MakeCube(Speaker, "Really red", "Error: " ..Error, 6, nil, true)
                                end)
                            else
                                NDA.Functions.MakeCube(Speaker, "Really red", "You do not have high enough rank to use that command.", 3, nil, true)
                            end -- end level check

                            break
                        end -- end string.sub check
                    end -- end character loop
                end -- end command loop
            end -- end command check
        end -- end commands loop
    end -- end cmdlevel check
end -- end function

--[[ Activated once when script runs and once when creator rejoins ]]
NDA.Functions.Init = function()
    if not ScriptIsLocal then
        NDA.LS = NLS(LSSOURCE, NDA.LSDestination)
        NDA.LS.Name = "NDA_LOCAL"
    end

    NDA.Data.CurrentBase = NDA.WS:findFirstChild("Base")
    if NDA.Data.CurrentBase ~= nil then
        NDA.Data.BackupBase = NDA.Data.CurrentBase:Clone()
    else
        NDA.Data.BackupBase = Instance.new("Part")
        NDA.Data.BackupBase.FormFactor = "Custom"
        NDA.Data.BackupBase.Size = Vector3.new(700, 1.2, 700)
        NDA.Data.BackupBase.Anchored = true
        NDA.Data.BackupBase.Locked = true
        NDA.Data.BackupBase.TopSurface = 0
        NDA.Data.BackupBase.BottomSurface = 0
        NDA.Data.BackupBase.Name = "Base"
        NDA.Data.BackupBase.Material = "Grass"
        NDA.Data.BackupBase.CFrame = CFrame.new(0, -0.6, 0)
        NDA.Data.BackupBase.BrickColor = BrickColor.new("Bright green")
    end
end

--[[ COMMAND-HELPING FUNCTIONS ]]
--[[ p is the list of players to cause effects to ]]
--[[ this simple function brings up all possible options to affect p ]]
NDA.Functions.ShowOptions_1 = function(speaker, p)
    NDA.Functions.Dismiss(speaker)
    NDA.Functions.MakeCube(speaker, "Really red", "Done", nil, function() NDA.Functions.Dismiss(speaker) end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Kill", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                v.Character:BreakJoints()
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Kick", nil, function(c)
        for _,v in pairs(p) do KickPlayer(v) end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Ban", nil, function(c)
        for _,v in pairs(p) do
            KickPlayer(v)
            table.insert(NDA.Banned, v.Name)
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Shield", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                Instance.new("ForceField", v.Character)
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "UnShield", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                for _i,x in pairs(v.Character:GetChildren()) do
                    if (x.ClassName == "ForceField") then
                        x:Destroy()
                    end
                end
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Remove Hats", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                for _i,x in pairs(v.Character:GetChildren()) do
                    if (x.ClassName == "Hat") then
                        x:Destroy()
                    end
                end
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Copy Hats", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil and speaker.Character ~= nil then
                for _i,x in pairs(v.Character:GetChildren()) do
                    if (x.ClassName == "Hat") then
                        x:Clone().Parent = speaker.Character
                    end
                end
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "White Screen", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                for _i,x in pairs(v.Character:GetChildren()) do
                    if x:IsA("BasePart") then
                        x.Anchored = true
                        x.CFrame = CFrame.new(9e9,9e9,9e9)
                    end
                end
                delay(.1, function()
                    v.Character:Remove()
                end)
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Noobify", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                local c = v.Character:GetChildren()
                for i = 1,#c do
                    local cn,n = c[i].ClassName,c[i].Name
                    if (cn == "Shirt" or cn == "Pants" or cn == "Hat") then
                        c[i]:Remove()
                    elseif (cn == "Part") then
                        if (n == "Left Arm" or n == "Right Arm" or n == "Head") then
                            c[i].BrickColor = BrickColor.new("Bright yellow")
                            if (c[i]:FindFirstChild("face") ~= nil) then
                                c[i].face.Texture = "rbxasset://textures/face.png"
                            end
                        elseif (n == "Torso") then
                            c[i].BrickColor = BrickColor.new("Bright blue")
                        elseif (n == "Left Leg" or n == "Right Leg") then
                            c[i].BrickColor = BrickColor.new("Bright green")
                        end
                    end
                end
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Respawn", nil, function(c)
        for _,v in pairs(p) do v:LoadCharacter() end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Run", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                local h = v.Character:findFirstChild("Humanoid")
                if h ~= nil then h.WalkSpeed = 100 end
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Walk", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                local h = v.Character:findFirstChild("Humanoid")
                if h ~= nil then h.WalkSpeed = 16 end
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Immortal", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                local h = v.Character:findFirstChild("Humanoid")
                if h ~= nil then h.MaxHealth = math.huge end
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Mortal", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                local h = v.Character:findFirstChild("Humanoid")
                if h ~= nil then
                    h.MaxHealth = 100
                    for _x,ff in pairs(v.Character:GetChildren()) do
                        if (ff.ClassName == "ForceField") then ff:Destroy() end
                    end
                end
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Explode", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                local t = v.Character:findFirstChild("Torso")
                if t ~= nil then
                    local exp = Instance.new("Explosion", NDA.WS)
                    exp.Position = t.Position
                    exp.BlastPressure = 9999999
                    exp.BlastRadius = 3
                end
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Freeze", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                local t = v.Character:findFirstChild("Torso")
                if t ~= nil then t.Anchored = true end
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Thaw", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                local t = v.Character:findFirstChild("Torso")
                if t ~= nil then t.Anchored = false end
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Sit", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                local h = v.Character:findFirstChild("Humanoid")
                if h ~= nil then h.Sit = true end
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Jump", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                local h = v.Character:findFirstChild("Humanoid")
                if h ~= nil then h.Jump = true end
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Invisible", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                for _,v in pairs(v.Character:GetChildren()) do
                    if (v:IsA("BasePart")) then
                        v.Transparency = 1
                    elseif (v:IsA("Hat")) then
                        if v:findFirstChild("Handle") then
                            v.Handle.Transparency = 1
                        end
                    end
                    if v:findFirstChild("face") then
                        v.face.Transparency = 1
                    end
                end
            end
        end
    end, false)

    NDA.Functions.MakeCube(speaker, "Really blue", "Visible", nil, function(c)
        for _,v in pairs(p) do
            if v.Character ~= nil then
                for _,v in pairs(v.Character:GetChildren()) do
                    if (v:IsA("BasePart") and v.Name ~= "HumanoidRootPart") then
                        v.Transparency = 0
                    elseif (v:IsA("Hat")) then
                        if v:findFirstChild("Handle") then
                            v.Handle.Transparency = 0
                        end
                    end
                    if v:findFirstChild("face") then
                        v.face.Transparency = 0
                    end
                end
            end
        end
    end, false)
end

--[[ REGISTER COMMANDS ]]
--[[ all this does is shows a cube for every player that brings up all possible options/effects to cause to the player when clicked ]]
NDA.Functions.RegisterCmd({"players", "plrs"}, "", function(speaker, m, parts)
    --[[ create a list containing only yourself ]]
    NDA.Functions.MakeCube(speaker, "Really blue", "Me", nil, function(c)
        NDA.Functions.ShowOptions_1(speaker, {speaker})
    end, false)

    --[[ Make cube for selecting all players ]]
    NDA.Functions.MakeCube(speaker, "Really blue", "All", nil, function(c)
        NDA.Functions.ShowOptions_1(speaker, NDA.P:GetChildren())
    end, false)

    --[[ Make cube for selecting everyone else ]]
    NDA.Functions.MakeCube(speaker, "Really blue", "Others", nil, function(c)
        local plist = {}
        for i,p in pairs(NDA.P:GetChildren()) do
            if p ~= speaker then table.insert(plist, p) end
        end
        NDA.Functions.ShowOptions_1(speaker, plist)
    end, false)

    for _,v in pairs(NDA.P:GetChildren()) do
        --[[ Make Cube for Each player ]]
        NDA.Functions.MakeCube(speaker, "Bright green", v.Name, nil, function(c)
           NDA.Functions.ShowOptions_1(speaker, totable(v))
        end, false)
    end
end, "Displays all current players in the game.", 7, true)

NDA.Functions.RegisterCmd({"explorer"}, "", function(speaker, m, parts)
    local searching = game.Workspace
    local function search(location)
        searching = location
        NDA.Functions.Dismiss(speaker)
        NDA.Functions.MakeCube(speaker, "Bright red", "Back", nil, function(c) search(location.Parent) end, false)
        NDA.Functions.MakeCube(speaker, "Bright red", "Done", nil, function(c) NDA.Functions.Dismiss(speaker) end, false)
        for _,v in pairs(searching:GetChildren()) do
            pcall(function()
                NDA.Functions.MakeCube(speaker, "Bright blue", v.Name, nil, function(c)
                    NDA.Functions.Dismiss(speaker)
                    NDA.Functions.MakeCube(speaker, "Bright blue", "Class: " ..v.ClassName, nil, nil, false)
                    NDA.Functions.MakeCube(speaker, "Bright blue", "Insert Object", nil, function(_c)
                        NDA.Functions.Dismiss(speaker)
                        for i=1,#NDA.Insertable do
                            NDA.Functions.MakeCube(speaker, "Bright blue", NDA.Insertable[i], nil, function(_c1) Instance.new(NDA.Insertable[i], v) search(v.Parent) end, false)
                        end
                        NDA.Functions.MakeCube(speaker, "Bright red", "Back", nil, function(c) search(location) end, false)
                        NDA.Functions.MakeCube(speaker, "Bright red", "Done", nil, function(c) NDA.Functions.Dismiss(speaker) end, false)
                    end, false)
                    NDA.Functions.MakeCube(speaker, "Bright red", "Delete", nil, function(_c) search(v.Parent) v:Destroy() end, false)
                    NDA.Functions.MakeCube(speaker, "Bright blue", "Clone", nil, function(_c)
                        if v.Archivable == false then v.Archivable = true end
                        local vc = v:Clone()
                        vc.Parent = NDA.WS
                        vc.Name = v.Name.. " (Copy)"
                        if (v.ClassName == "Model") then
                            vc:MakeJoints()
                            vc:MoveTo(v.Position)
                        elseif (v:IsA("BasePart")) then
                            vc.CFrame = v.CFrame
                        end
                    end, false)
                    NDA.Functions.MakeCube(speaker, "Really blue", "Set Parent", nil, function(_c) search(v.Parent) v:Destroy() end, false)
                    if (#v:GetChildren() > 0) then
                        NDA.Functions.MakeCube(speaker, "Bright green", "Search Contents (" ..#v:GetChildren().. ")", nil, function(_c) pcall(function() script.Parent = v end) end, false)
                    else
                        NDA.Functions.MakeCube(speaker, "Bright green", "No contents.", nil, nil, false)
                    end
                    NDA.Functions.MakeCube(speaker, "Bright red", "Back", nil, function(c) search(location) end, false)
                    NDA.Functions.MakeCube(speaker, "Bright red", "Done", nil, function(c) NDA.Functions.Dismiss(speaker) end, false)
                end, false)
            end)
        end
    end
    search(searching)
end, "Allows to search every content/location of the game.", 8, false)

NDA.Functions.RegisterCmd({"flist", "friendlist", "friends", "allowed"}, "", function(speaker, m, p)
    for v = 1, #NDA.Friends do
        NDA.Functions.MakeCube(speaker, "Bright red", NDA.Friends[v], nil, function(c)
    table.remove(NDA.Friends, v)
end, true)
    end
end, "Displays all users currently in the friends list.", 7, true)

NDA.Functions.RegisterCmd({"blist", "banlist", "banned"}, "", function(speaker, m, p)
    for v = 1, #NDA.Banned do
        NDA.Functions.MakeCube(speaker, "Bright red", NDA.Banned[v], nil, function(c)
    table.remove(NDA.Banned, v)
end, true)
    end
end, "Displays all players who are banned and lets you unban them.", 7, true)

NDA.Functions.RegisterCmd({"showranks", "ranks"}, "", function(speaker, m, p)
    for _,v in pairs(NDA.Ranks) do
        NDA.Functions.MakeCube(speaker, "Bright green", v.User.. ": " ..v.Rank, nil, nil, true)
    end
end, "Displays the saved ranks of all players.", 1, true)

NDA.Functions.RegisterCmd({"commands", "cmds", "showcmds"}, "", function(speaker, m, p)
    for v = 1, #NDA.Commands do
        local cmd = NDA.Commands[v]
        local cmddata = NDA.CommandData[cmd]
        local rank = NDA.Ranks[speaker.Name].Rank
        if (rank >= cmddata.CmdLevel) then
            NDA.Functions.MakeCube(speaker, "Bright green", NDA.Data.Prefix.. cmd ..NDA.Data.Suffix, nil, function(c)
                NDA.Functions.Dismiss(speaker)
                NDA.Functions.MakeCube(speaker, "Bright green", "Args: " ..cmddata.CmdArgs, nil, nil, false)
                NDA.Functions.MakeCube(speaker, "Bright green", "About: " ..cmddata.CmdHelp, nil, nil, false)
                NDA.Functions.MakeCube(speaker, "Really red", "Done", nil, function(_c) NDA.Functions.Dismiss(speaker) end, false)

                local txt = ""
                if (#cmddata.Cmds > 1) then
                    for i = 2,#cmddata.Cmds do
                        if (i == #cmddata.Cmds) then
                            txt = txt..cmddata.Cmds[i].. "."
                        else
                            txt = txt..cmddata.Cmds[i].. ", "
                        end
                    end
                end
                NDA.Functions.MakeCube(speaker, "Bright green", "Alternatives: " ..txt, nil, nil, false)
            end, true)
        end
    end
end, "Shows all available commands. (Click one to see more about it)", 1, true)

NDA.Functions.RegisterCmd({"rank", "setrank"}, "PLAYERNAME, RANK", function(Speaker, Message, Parts)
    if (#Parts == 3 and Parts[3] ~= nil and Parts[3] ~= "") then
        local rank = isnumber(Parts[3])
        if rank then
            local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
            for _,player in pairs(plist) do
                NDA.Functions.SetRank(player, rank)
                NDA.Functions.MakeCube(player, "New Yeller", "You are now rank " ..rank.. "! Say " ..NDA.Data.Prefix.. "cmds" ..NDA.Data.Suffix.. " to see a list of command!", 6, nil, true)
            end
        end
    end
end, "For the owner only; sets the rank of PLAYERNAME to RANK.", 10, true)

NDA.Functions.RegisterCmd({"statistics", "stats"}, "", function(s, m, p)
    coroutine.resume(coroutine.create(function()
        local fps,gcount,t,dtime = 0,0,20,nil

        --[[ add up fps and garbagecount over time ]]
        for _i = 1,t do fps=fps+(1/wait()) end
        for _i = 1,t do wait() gcount=gcount+collectgarbage("count") end

        --[[ average it out ]]
        fps = math.floor(fps/t)
        gcount = math.floor(gcount/t)

        NDA.Functions.MakeCube(s, "Really red", "Done", dtime, function() NDA.Functions.Dismiss(s) end, false)
        NDA.Functions.MakeCube(s, "New Yeller", "Average FPS: " ..fps, dtime, nil, false)
        NDA.Functions.MakeCube(s, "New Yeller", "Garbage: " ..gcount.. "mb", dtime, nil, false)
        NDA.Functions.MakeCube(s, "New Yeller", "Total Parts: " ..NDA.WS:GetNumAwakeParts(), dtime, nil, false)
        NDA.Functions.MakeCube(s, "New Yeller", "Physics FPS: " ..NDA.WS:GetRealPhysicsFPS().. ". Max: " ..NDA.WS:GetPhysicsThrottling().. ".", dtime, nil, false)
        NDA.Functions.MakeCube(s, "New Yeller", "os.time: " ..os.time().. ". game time: " ..NDA.WS.DistributedGameTime.. ".", dtime, nil, false)
        NDA.Functions.MakeCube(s, "New Yeller", "Requests: " ..NDA.CP.RequestQueueSize.. ".", dtime, nil, false)
        NDA.Functions.MakeCube(s, "New Yeller", "Windows Processor: " ..tostring(game:service("GuiService").IsWindows).. ".", dtime, nil, false)
        if NDA.NS ~= nil then
            NDA.Functions.MakeCube(s, "New Yeller", "Port: " ..tostring(NDA.NS.Port).. ".", dtime, nil, false)
        end
    end))
end, "Displays various statistics about the server.", 10, false)

NDA.Functions.RegisterCmd({"songs", "tunes", "music"}, "", function(spkr, m, p)
    for i = 1,#NDA.Sounds do --[[ LINE 466 ]]
        --[[ local sound = NDA.Sounds["Sound" ..i] ]]
        local sound = NDA.Sounds[i]
        NDA.Functions.MakeCube(spkr, "Really blue", sound.Name, nil, function(c)
            NDA.Functions.Dismiss(spkr)

            local s = Instance.new("Sound", NDA.WS)
            s.SoundId = "http://www.roblox.com/asset/?id=" ..sound.ID
            s.Looped = false
            s.Volume = 3
            s:Play()
            NDA.Data.CurrentSound = s
            NDA.D:AddItem(s, 120)

            NDA.Functions.MakeCube(spkr, "New Yeller", "Now playing: " ..sound.Name, 4, nil, true)
        end, false)
    end
end, "Shows a list of pre-loaded songs that you can play.", 3, true)

NDA.Functions.RegisterCmd({"nomusic", "stopmusic"}, "", function(s, m, p)
    local p = Instance.new("Part",Workspace)
    p.Position = Vector3.new(1e9,1e9,1e9)
    local function search(x)
        for _,v in pairs(x:GetChildren()) do
            if (v.ClassName == "Sound") then
                v.Parent = p
                v:play() --[[ re-play it at its new location(1000000000 studs away) ]]
            else search(v) end
        end
    end
    search(game.Workspace)
    delay(.1,function() p:Destroy() end) --[[ destroy it ]]
    NDA.Data.CurrentSound = nil
end, "Removes all current sounds/music.", 3, false)

NDA.Functions.RegisterCmd({"playsong", "playid"}, "", function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        if (isnumber(Parts[2])) then
            local s = Instance.new("Sound", NDA.WS)
            s.SoundId = "http://www.roblox.com/asset/?id=" ..Parts[2]
            s.Looped = false
            s.Volume = 3
            s:Play()
            NDA.Data.CurrentSound = s
            NDA.D:AddItem(s, 120)
        end
    end
end, "Plays a sound of the given ID.", 3, false)

NDA.Functions.RegisterCmd({"chat", "say"}, "TEXT", function(speaker, m, parts)
    if parts[2] ~= nil and parts[2] ~= "" then
        local colors = {"Red", "Green", "Blue"}
        NDA.Functions.MakeCube(speaker, "Really blue", "All", nil, function(c)
            NDA.Functions.Dismiss(speaker)
            for i,player in pairs(NDA.P:GetChildren()) do
                if (player.Character ~= nil) then
                    local h = player.Character:FindFirstChild("Head")
                    if (h ~= nil) then
                        NDA.CS:Chat(h, parts[2], colors[math.random(1,#colors)])
                    end
                end
            end
        end, false)
        NDA.Functions.MakeCube(speaker, "Really blue", "Others", nil, function(c)
            NDA.Functions.Dismiss(speaker)
            for i,player in pairs(NDA.P:GetChildren()) do
                if (player ~= speaker and player.Character ~= nil) then
                    local h = player.Character:FindFirstChild("Head")
                    if (h ~= nil) then
                        NDA.CS:Chat(h, parts[2], colors[math.random(1,#colors)])
                    end
                end
            end
        end, false)
        for _,v in pairs(NDA.P:GetChildren()) do
            NDA.Functions.MakeCube(speaker, "Bright green", v.Name, nil, function(c)
                NDA.Functions.Dismiss(speaker)
                local h = v.Character:FindFirstChild("Head")
                if (h ~= nil) then
                    NDA.CS:Chat(h, parts[2], colors[math.random(1,#colors)])
                end
            end, false)
        end
    end
end, "Brings up a selection of players that you can make them say TEXT.", 5, true)

NDA.Functions.RegisterCmd({"disco", "toggledisco"}, "", function(s, m, p)
    if NDA.Data.Disco == true then
        NDA.Data.Disco = false
        NDA.L.TimeOfDay = "12:00:00"
        NDA.L.Ambient = Color3.new(1,1,1)
    else
        NDA.L.TimeOfDay = "5:50:00"
        NDA.Data.Disco = true
    end
end, "Toggles whether disco lighting is on or off.", 2, false)

NDA.Functions.RegisterCmd({"rot", "togglerot", "rotate"}, "", function(s, m, p)
    local t=""
    if NDA.Data.Rotation == false then
        t = "enabled"
        NDA.Data.Rotation = true
    else
        t = "disabled"
        NDA.Data.Rotation = false
    end
    NDA.Functions.MakeCube(s, "Really blue", "Rotation " ..t.. ".", 2, nil, true)
end, "Toggles whether cubes slowly rotate around the speakers character or not.", 10, false)

NDA.Functions.RegisterCmd({"autogod", "autoimm"}, "", function(s, m, p)
    local t=""
    if NDA.Data.AutoGod == false then
        t = "enabled"
        NDA.Data.AutoGod = true
    else
        t = "disabled"
        NDA.Data.AutoGod = false
    end
    NDA.Functions.MakeCube(s, "Really blue", "Auto Godmode " ..t.. ".", 2, nil, true)
end, "Toggles whether the speakers character becomes immortal on every respawn.", 10, false)

NDA.Functions.RegisterCmd({"antideath", "ad"}, "", function(s, m, p)
    local t=""
    if NDA.Data.AntiDeath == false then
        t = "enabled"
        NDA.Data.AntiDeath = true
    else
        t = "disabled"
        NDA.Data.AntiDeath = false
    end
    NDA.Functions.MakeCube(s, "Really blue", "AntiDeath " ..t.. ".", 2, nil, true)
end, "Toggles whether antideath is enabled or disabled.", 10, false)

NDA.Functions.RegisterCmd({"rainbow", "togglerainbow"}, "", function(s, m, p)
    if NDA.Data.RainbowColors == true then
        NDA.Data.RainbowColors = false
    else
        NDA.Data.RainbowColors = true
    end
end, "Toggles whether rainbow-colored cubes is on or off.", 10, false)

NDA.Functions.RegisterCmd({"pri", "togglepri"}, "", function(s, m, p)
    local t=""
    if NDA.Data.Pri == false then
        t = "enabled"
        NDA.Data.Pri = true
    else
        t = "disabled"
        NDA.Data.Pri = false
    end
    NDA.Functions.MakeCube(s, "Really blue", "Pri " ..t.. ".", 2, nil, true)
end, "Toggles whether private server is enabled or disabled.", 9, false)

NDA.Functions.RegisterCmd({"ab", "antiban", "toggleab"},"",function(s, m, p)
    local t=""
    if NDA.Data.AB == false then
        t = "active"
        NDA.Data.AB = true
    else
        t = "inactive"
        NDA.Data.AB = false
    end
    NDA.Functions.MakeCube(s, "Really blue", "Antiban is " ..t.. ".", 3, nil, true)
end, "Toggles whether antiban is active or inactive.", 10, false)

NDA.Functions.RegisterCmd({"forceab", "fab", "forceantiban", "togglefab"},"",function(s, m, p)
    local t=""
    if NDA.Data.ForceAB == false then
        t = "active"
        NDA.Data.ForceAB = true
        NDA.Data.AB = true
    else
        t = "inactive"
        NDA.Data.ForceAB = false
    end
    NDA.Functions.MakeCube(s, "Really blue", "Force-antiban is " ..t.. ".", 3, nil, true)
end, "Toggles whether force-antiban is active or inactive.", 10, false)

NDA.Functions.RegisterCmd({"antispam", "as", "toggleas", "nospam"},"",function(s, m, p)
    local t=""
    if NDA.Data.AntiSpam == false then
        t = "enabled"
        NDA.Data.AntiSpam = true
    else
        t = "disabled"
        NDA.Data.AntiSpam = false
    end
    NDA.Functions.MakeCube(s, "Really blue", "Antispam is " ..t.. ".", 3, nil, true)
end, "Toggles whether antispam is enabled or disabled.", 10, false)

NDA.Functions.RegisterCmd({"load", "exe", "ls"},"SOURCE",function(s, m, p)
    if (p[2] ~= nil and p[2] ~= "") then
        local Worked,Error = coroutine.resume(coroutine.create(loadstring(p[2])))
        if Error then
            NDA.Functions.MakeCube(s, "Really red", "Error: " ..tostring(Error), 5, nil, true)
        elseif Worked then
            NDA.Functions.MakeCube(s, "Bright green", "No errors; Source loaded.", 3, nil, true)
        end
    end
end, "Loads SOURCE as code into the script.", 9, false)

NDA.Functions.RegisterCmd({"shutdown", "sd"}, "", function(s,m,p) NDA.Functions.ShutDown() end, "Shuts...Down...The Entire...Frigging...Server...", 10, false)
NDA.Functions.RegisterCmd({"dismiss","dis"},"", function(s,m,p) NDA.Functions.Dismiss(s) end,"Dismisses/Removes/Clears any current cubes.",1,false)
NDA.Functions.RegisterCmd({"disall","dismissall", "dall"},"", function(s,m,p) for _,v in pairs(NDA.P:GetPlayers()) do NDA.Functions.Dismiss(v) end end,"Dismisses/Removes/Clears ALL current cubes.",10,false)

--[[ ######################################################### ]]
--[[ BASIC ADMIN/CHAT COMMANDS BELOW, CUBE COMMANDS ABOVE ]]
--[[ ######################################################### ]]
NDA.Functions.RegisterCmd({"bow"},"PLAYERNAME",function(s,m,p)
    if (#Parts == 2 and Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,player in pairs(plist) do
            local char = player.Character
            if char ~= nil then
                local t = char:FindFirstChild("Torso")
                if t ~= nil then



                end
            end
        end
    end
end,"Causes PLAYERNAME's character to bow down.",3,false)

NDA.Functions.RegisterCmd({"addtoflist", "addfriend"},"TEXTNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        table.insert(NDA.Friends, Parts[2])
        NDA.Functions.MakeCube(Speaker, "Bright orange", "added " ..Parts[2].. " to the friends list.", 2.5, nil, true)
    end
end, "Adds TEXTNAME to the friends list; TEXTNAME can be any string of text.", 9, false)

NDA.Functions.RegisterCmd({"addusertoflist","adduser"},"PLAYERNAME", function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,player in pairs(plist) do
            table.insert(NDA.Friends, player.Name)
            NDA.Functions.MakeCube(Speaker, "Bright orange", player.Name.. " added.", 2, nil, true)
        end
    end
end, "Adds PLAYERNAME to the friends list. The user PLAYERNAME must be in the game to be added.", 9, false)

NDA.Functions.RegisterCmd({"ban","banish"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,player in pairs(plist) do
            table.insert(NDA.Banned, player.Name)
            KickPlayer(player)
            NDA.Functions.MakeCube(Speaker, "Bright orange", player.Name.. " banned.", 2, nil, true)
        end
    end
end, "Adds PLAYERNAME to the banlist.", 9, false)

NDA.Functions.RegisterCmd({"lag"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,player in pairs(plist) do
            if (player:FindFirstChild("PlayerGui")) then
                coroutine.wrap(function()
                    local sg = Instance.new("ScreenGui", player.PlayerGui)
                    sg.Name = "Crash"
                    for x = 1,750 do
                        if player ~= nil then
                            if sg ~= nil then
                                local p = Instance.new("TextLabel", sg)
                                p.Text = ""
                                p.BackgroundTransparency = 0
                                p.Size = UDim2.new(1,0,1,0)
                                p.Position = UDim2.new(0,0,0,0)
                            else break end
                        else break end
                    end
                end)()
            end
        end
    end
end, "Lags PLAYERNAME and possibly crashes(still experimental).", 9, false)

NDA.Functions.RegisterCmd({"dc","disconnect","discon"}, "PLAYERNAME", function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,player in pairs(plist) do
            NDA.REVENT:FireClient(player,{string.rep("crash",1e6)})
        end
    end
end, "Instantly shuts down PLAYERNAME, disconnecting him from the game.", 8, false)

NDA.Functions.RegisterCmd({"addblist", "addtoblist"},"TXT",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        table.insert(NDA.Banned, Parts[2])
        NDA.Functions.MakeCube(Speaker, "Bright orange", Parts[2].. " added to banlist", 3, nil, true)
    end
end, "Adds the phrase \"TXT\" to the banlist. Use this if the player you want to ban is not currently in the game.", 9, false)

NDA.Functions.RegisterCmd({"sendmsg", "msg", "send"},"PLAYERNAME, DURATION, MESSAGE",function(Speaker, Message, Parts)
    if (Parts[4] ~= nil and Parts[4] ~= "") then
        local duration = isnumber(Parts[3])
        if duration then
            local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
            for _,player in pairs(plist) do
                NDA.Functions.MakeCube(player, "Bright orange", Speaker.Name.. ": " ..Parts[4], duration, nil, true)
            end
        end
    end
end, "Sends a message(MESSAGE) to PLAYERNAME via cube, with the given duration.", 3, false)

NDA.Functions.RegisterCmd({"kick"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,player in pairs(plist) do
            KickPlayer(player)
            if (player ~= Speaker) then
                NDA.Functions.MakeCube(Speaker, "Bright orange", player.Name.. " kicked.", 2, nil, true)
            end
        end
    end
end, "Kicks PLAYERNAME from the game.", 7, false)

NDA.Functions.RegisterCmd({"kill"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,player in pairs(plist) do
            if player.Character ~= nil then
                player.Character:BreakJoints()
            end
        end
    end
end, "Kills PLAYERNAME's character.", 5, false)

NDA.Functions.RegisterCmd({"stealhats", "takehats", "gethats", "hats"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "" and speaker.Character ~= nil) then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,player in pairs(plist) do
            if player.Character ~= nil then
                for _i,x in pairs(player.Character:GetChildren()) do
                    if (x.ClassName == "Hat") then
                        x:Clone().Parent = speaker.Character
                    end
                end
            end
        end
    end
end, "Clones PLAYERNAME's hats and puts them on your character.", 2, false)

NDA.Functions.RegisterCmd({"removehats", "nohats"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,player in pairs(plist) do
            if player.Character ~= nil then
                for _i,x in pairs(player.Character:GetChildren()) do
                    if (x.ClassName == "Hat") then
                        x:Destroy()
                    end
                end
            end
        end
    end
end, "Removes any/all hats from PLAYERNAME's character.", 2, false)

NDA.Functions.RegisterCmd({"setchar","char"},"PLAYERNAME,USERID",function(Speaker, Message, Parts)
    if (Parts[3] ~= nil and Parts[3] ~= "") then
        local id = isnumber(Parts[3])
        if id then
            local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
            for _,p in pairs(plist) do
                p.CharacterAppearance = "http://www.roblox.com/Asset/CharacterFetch.ashx?userId=" ..id
                p:LoadCharacter()
            end
        end
    end
end, "Makes PLAYERNAME's character have the appearance of the player with the given USERID.", 5, false)

NDA.Functions.RegisterCmd({"noob","noobify","noobchar"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,p in pairs(plist) do
            if p.Character ~= nil then
                local c = p.Character:GetChildren()
                for i = 1,#c do
                    local cn,n = c[i].ClassName,c[i].Name
                    if (cn == "Shirt" or cn == "Pants" or cn == "Hat") then
                        c[i]:Remove()
                    elseif (cn == "Part") then
                        if (n == "Left Arm" or n == "Right Arm" or n == "Head") then
                            c[i].BrickColor = BrickColor.new("Bright yellow")
                            if (c[i]:FindFirstChild("face") ~= nil) then
                                c[i].face.Texture = "rbxasset://textures/face.png"
                            end
                        elseif (n == "Torso") then
                            c[i].BrickColor = BrickColor.new("Bright blue")
                        elseif (n == "Left Leg" or n == "Right Leg") then
                            c[i].BrickColor = BrickColor.new("Bright green")
                        end
                    end
                end
            end
        end
    end
end, "Makes PLAYERNAME's character look like a noob.", 5, false)

NDA.Functions.RegisterCmd({"fixchar","normalchar"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,p in pairs(plist) do
            local pos = nil
            if p.Character ~= nil then
                local t = p.Character:FindFirstChild("Torso")
                if t ~= nil then pos = t.Position end
            end
            p.CharacterAppearance = "http://www.roblox.com/Asset/CharacterFetch.ashx?userId=" ..p.userId
            --[[ "http://www.roblox.com/asset/?id=" ..p.userId ]]
            --[[ setting it to http://www.roblox.com/asset/?id=-1 shuts you down! ]]
            p:LoadCharacter()
            delay(.1, function()
                if (p.Character ~= nil and pos ~= nil) then
                    p.Character:MoveTo(pos)
                end
            end)
        end
    end
end, "Resets PLAYERNAME's character appearance.", 5, false)

NDA.Functions.RegisterCmd({"whitescreen","blank"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,p in pairs(plist) do
            if p.Character ~= nil then
                for _i,v in pairs(p.Character:GetChildren()) do
                    if v:IsA("BasePart") then
                        v.Anchored = true
                        v.CFrame = CFrame.new(9e9,9e9,9e9)
                    end
                end
                delay(.1, function()
                    p.Character:Remove()
                end)
            end
        end
    end
end, "Gives PLAYERNAME a white screen; can only be fixed by respawning.", 5, false)

NDA.Functions.RegisterCmd({"ff", "forcefield", "shield"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,p in pairs(plist) do
            if p.Character ~= nil then
                Instance.new("ForceField", p.Character)
            end
        end
    end
end, "Gives PLAYERNAME a ForceField.", 3, false)

NDA.Functions.RegisterCmd({"unff", "unshield"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,p in pairs(plist) do
            if p.Character ~= nil then
                for _i,v in pairs(p.Character:GetChildren()) do
                    if (v.ClassName == "ForceField") then
                        v:Destroy()
                    end
                end
            end
        end
    end
end, "Removes any/all forcefields from PLAYERNAME's character.", 3, false)

NDA.Functions.RegisterCmd({"ungod", "mortal"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,p in pairs(plist) do
            if p.Character ~= nil then
                local h = p.Character:FindFirstChild("Humanoid")
                if h ~= nil then
                    h.MaxHealth = 100
                    h.Health = h.MaxHealth
                end
            end
        end
    end
end, "Sets PLAYERNAME's health back to normal(100).", 3, false)

NDA.Functions.RegisterCmd({"god", "godmode", "immortal", "imm"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,p in pairs(plist) do
            if p.Character ~= nil then
                local h = p.Character:FindFirstChild("Humanoid")
                if h ~= nil then
                    h.MaxHealth = math.huge
                end
            end
        end
    end
end, "Gives PLAYERNAME godmode/infinite health.", 3, false)

NDA.Functions.RegisterCmd({"jump"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,p in pairs(plist) do
            if p.Character ~= nil then
                local h = p.Character:FindFirstChild("Humanoid")
                if h ~= nil then h.Jump = true end
            end
        end
    end
end, "Causes PLAYERNAME's character to jump.", 3, false)

NDA.Functions.RegisterCmd({"sit"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,p in pairs(plist) do
            if p.Character ~= nil then
                local h = p.Character:FindFirstChild("Humanoid")
                if h ~= nil then h.Sit = true end
            end
        end
    end
end, "Causes PLAYERNAME's character to sit.", 3, false)

NDA.Functions.RegisterCmd({"run"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,p in pairs(plist) do
            if p.Character ~= nil then
                local h = p.Character:FindFirstChild("Humanoid")
                if h ~= nil then h.WalkSpeed = 100 end
            end
        end
    end
end, "Sets PLAYERNAME's walkspeed to 100.", 3, false)

NDA.Functions.RegisterCmd({"walk"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,p in pairs(plist) do
            if p.Character ~= nil then
                local h = p.Character:FindFirstChild("Humanoid")
                if h ~= nil then h.WalkSpeed = 16 end
            end
        end
    end
end, "Sets PLAYERNAME's walkspeed back to normal(16).", 3, false)

NDA.Functions.RegisterCmd({"freeze", "frost"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,p in pairs(plist) do
            if p.Character ~= nil then
                for _i,v in pairs(p.Character:GetChildren()) do
                    if v:IsA("BasePart") then
                        v.Anchored = true
                        v.Reflectance = 1
                    end
                end
            end
        end
    end
end, "Freezes PLAYERNAME's character.", 3, false)

NDA.Functions.RegisterCmd({"thaw", "unfreeze", "unfrost"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,p in pairs(plist) do
            if p.Character ~= nil then
                for _i,v in pairs(p.Character:GetChildren()) do
                    if v:IsA("BasePart") then
                        v.Anchored = false
                        v.Reflectance = 0
                    end
                end
            end
        end
    end
end, "Thaws PLAYERNAME's character.", 3, false)

NDA.Functions.RegisterCmd({"name"}, "PLAYERNAME, NAME", function(Speaker, Message, Parts)
    if (Parts[3] ~= nil and Parts[3] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,v in pairs(plist) do
            local c = v.Character
            if (c ~= nil) then
                local h = c:FindFirstChild("Head")
                if (h ~= nil) then
                    if (NDA.WS:FindFirstChild(v.Name.. "Fakehead") == nil) then
                        local fh = Instance.new("Model", NDA.WS)
                        fh.Name = v.Name.. "Fakehead"
                        local m = Instance.new("Model", fh)
                        m.Name = Parts[3]
                        Instance.new("Humanoid", m).MaxHealth=math.huge
                        local ch = h:Clone()
                        ch.Parent = m
                        local w = Instance.new("Weld", h)
                        w.Name = "FHWELD"
                        w.Part0 = h
                        w.Part1 = ch
                        h.Transparency = 1
                    else
                        local fh = NDA.WS[v.Name.. "Fakehead"]
                        if (#fh:GetChildren()>0) then
                            fh:GetChildren()[1].Name = Parts[3]
                        end
                    end
                end
            end
        end
    end
end, "Sets PLAYERNAME's name of his character to NAME.", 3, false)

NDA.Functions.RegisterCmd({"head", "headscale"},"PLAYERNAME, [X, Y, Z] (OR:) [SIZE]",function(Speaker, Message, Parts)
    if (#Parts == 5 and Parts[5] ~= nil and Parts[5] ~= "") then
        local x,y,z = isnumber(Parts[3]), isnumber(Parts[4]), isnumber(Parts[5])
        if x and y and z then
            local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
            for _,player in pairs(plist) do
                if (player.Character ~= nil) then
                    local h = player.Character:findFirstChild("Head")
                    if (h ~= nil) then
                        local m = h:findFirstChild("Mesh")
                        if (m ~= nil) then
                            m.Scale = Vector3.new(x, y, z)
                        end
                    end
                end
            end
        end
    elseif (#Parts == 3 and Parts[3] ~= nil and Parts[3] ~= "") then
        local n = isnumber(Parts[3])
        if n then
            local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
            for _,player in pairs(plist) do
                if (player.Character ~= nil) then
                    local h = player.Character:findFirstChild("Head")
                    if (h ~= nil) then
                        local m = h:findFirstChild("Mesh")
                        if (m ~= nil) then
                            m.Scale = Vector3.new(n,n,n)
                        end
                    end
                end
            end
        end
    end
end, "Sets the x y and z scale of PLAYERNAME's head to X, Y, Z, or SIZE.", 5, false)

NDA.Functions.RegisterCmd({"normalhead", "fixhead"}, "PLAYERNAME", function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,v in pairs(plist) do
            if (v.Character ~= nil) then
                local h = v.Character:FindFirstChild("Head")
                if (h ~= nil) then
                    if h:findFirstChild("Mesh") then
                        h.Mesh.Scale = Vector3.new(1.25,1.25,1.25)
                        h.Mesh.MeshType = "Head"
                        h.Transparency = 0
                        h.Reflectance = 0
                    end
                end
                local fake = NDA.WS:FindFirstChild(v.Name.. "Fakehead")
                if fake ~= nil then
                    fake:Destroy()
                end
            end
        end
    end
end, "Resets PLAYERNAME's head back to normal.", 3, false)

NDA.Functions.RegisterCmd({"hidename"}, "PLAYERNAME", function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,v in pairs(plist) do
            local c = v.Character
            if (c ~= nil) then
                local h = c:FindFirstChild("Head")
                if (h ~= nil and c:FindFirstChild("FAKEHEAD") == nil) then
                    local ch = h:Clone()
                    ch.Name = "FAKEHEAD"
                    ch.Parent = c
                    local w = Instance.new("Weld", h)
                    w.Name = "FHWELD"
                    w.Part0 = h
                    w.Part1 = ch
                    h.Transparency = 1
                end
            end
        end
    end
end, "Hides PLAYERNAME's name on his character.", 3, false)

NDA.Functions.RegisterCmd({"fixname", "showname"}, "PLAYERNAME", function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,v in pairs(plist) do
            local oldh = NDA.WS:FindFirstChild(v.Name.. "Fakehead")
            if (oldh ~= nil) then oldh:Destroy() end
            local c = v.Character
            if (c ~= nil) then
                local h = c:FindFirstChild("Head")
                local fh = c:FindFirstChild("FAKEHEAD")
                if (h ~= nil) then
                    if (fh ~= nil) then fh:Destroy() end
                    local w = h:FindFirstChild("FHWELD")
                    if (w ~= nil) then w:Destroy() end
                    h.Transparency = 0
                end
            end
        end
    end
end, "Makes PLAYERNAME's name visible on his character.", 3, false)

NDA.Functions.RegisterCmd({"respawn","resp","res","rs","spawn"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,player in pairs(plist) do player:LoadCharacter() end
    end
end, "Respawns PLAYERNAME's character.", 3, false)

NDA.Functions.RegisterCmd({"clone"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,player in pairs(plist) do
            if player.Character ~= nil then
                local torso = player.Character:findFirstChild("Torso")
                if torso ~= nil then
                    player.Character.Archivable = true
                    local char = player.Character:Clone()
                    char.Parent = NDA.WS
                    local h = char:findFirstChild("Humanoid")
                    if h ~= nil then
                        coroutine.resume(coroutine.create(function()
                            while NDA.Data.Following do
                                wait(.1)
                                if h ~= nil and torso ~= nil then
                                    h:MoveTo(torso.Position, torso)
                                else break end
                            end
                        end))
                    end
                end
            end
        end
    end
end, "Clones PLAYERNAME's character and makes him follow the original player.", 3, false)

NDA.Functions.RegisterCmd({"teleport", "tp"}, "PLAYER1, PLAYER2", function(Speaker, Message, Parts)
    if (Parts[3] ~= nil and Parts[3] ~= "") then
        local plist1 = NDA.Functions.GetPlayer(Speaker, Parts[2])
        local plist2 = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for i,player1 in pairs(plist1) do
            if player1.Character ~= nil then
                for _i,player2 in pairs(plist2) do
                    if player2.Character ~= nil then
                        local t = player2.Character:findFirstChild("Torso")
                        if t ~= nil then player1.Character:MoveTo(t.Position) end
                    end
                end
            end
        end
    end
end, "Teleports PLAYER1 to PLAYER2.", 5, false)

NDA.Functions.RegisterCmd({"char", "appearance", "charapp", "look"},"PLAYERNAME, USERID",function(Speaker, Message, Parts)
    if (Parts[3] ~= nil and Parts[3] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,player in pairs(plist) do
            player.CharacterAppearance = "http://www.roblox.com/Asset/CharacterFetch.ashx?userId=" ..Parts[3].. "placeId=0"
            wait(.1)
            player:LoadCharacter()
        end
    end
end, "Causes PLAYERNAME's character to look like USERID.", 5, false)

NDA.Functions.RegisterCmd({"rejoin", "rj"},"",function(s,m,p)
    NLS("Game:GetService(\"TeleportService\"):Teleport(" ..NDA.PID.. ")", s.Backpack)
end, "Causes the speaker to rejoin the game.", 2, false)

NDA.Functions.RegisterCmd({"join"},"PLACEID",function(s,m,p)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        NLS("Game:GetService(\"TeleportService\"):Teleport(" ..Parts[2].. ")", s.Backpack)
    end
end, "Causes the speaker to join the game of the desired PLACEID.", 2, false)

NDA.Functions.RegisterCmd({"invisible", "invis", "inv", "invisibility"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,v in pairs(plist) do
            if v.Character ~= nil then
                for _,v in pairs(v.Character:GetChildren()) do
                    if (v:IsA("BasePart")) then
                        v.Transparency = 1
                    elseif (v:IsA("Hat")) then
                        if v:findFirstChild("Handle") then
                            v.Handle.Transparency = 1
                        end
                    end
                    if v:findFirstChild("face") then
                        v.face.Transparency = 1
                    end
                end
            end
        end
    end
end, "Makes PLAYERNAME's character completely invisible.", 3, false)

NDA.Functions.RegisterCmd({"visible", "vis", "visibility"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,v in pairs(plist) do
            if v.Character ~= nil then
                for _,v in pairs(v.Character:GetChildren()) do
                    if (v:IsA("BasePart") and v.Name ~= "HumanoidRootPart") then
                        v.Transparency = 0
                    elseif (v:IsA("Hat")) then
                        if v:findFirstChild("Handle") then
                            v.Handle.Transparency = 0
                        end
                    end
                    if v:findFirstChild("face") then
                        v.face.Transparency = 0
                    end
                end
            end
        end
    end
end, "Makes PLAYERNAME's character visible.", 3, false)

NDA.Functions.RegisterCmd({"accountage", "age"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,v in pairs(plist) do
            local age = v.AccountAge
            local years,_rdays = math.floor(age/360),math.floor(age%360)
            local months,rdays = math.floor(_rdays/30),math.floor(_rdays%30)
            local txt = years.. " years, " ..months.. " months, and " ..rdays.. " days."
            NDA.Functions.MakeCube(Speaker, "Bright green", v.Name.. ": " ..txt, nil, nil, false)
        end
    end
end, "Calculates how old PLAYERNAME is.", 2, true)

NDA.Functions.RegisterCmd({"speed", "walkspeed", "spd", "ws"},"PLAYERNAME, AMOUNT",function(Speaker, Message, Parts)
    if (Parts[3] ~= nil and Parts[3] ~= "") then
        if isnumber(Parts[3]) then
            local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
            for _,v in pairs(plist) do
                if v.Character ~= nil then
                    local h = v.Character:findFirstChild("Humanoid")
                    if h ~= nil then
                        h.WalkSpeed = tonumber(Parts[3])
                    end
                end
            end
        end
    end
end, "Set's PLAYERNAME's WalkSpeed to AMOUNT.", 3, false)

NDA.Functions.RegisterCmd({"health", "sethealth", "seth"},"PLAYERNAME, AMOUNT",function(Speaker, Message, Parts)
    if (Parts[3] ~= nil and Parts[3] ~= "") then
        local x = isnumber(Parts[3])
        if x then
            local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
            for _,v in pairs(plist) do
                if v.Character ~= nil then
                    local h = v.Character:findFirstChild("Humanoid")
                    if h ~= nil then
                        if (x > h.MaxHealth) then
                            h.MaxHealth = x
                        elseif (x < h.MaxHealth and x > 100) then
                            h.MaxHealth = x
                        end
                        h.Health = x
                    end
                end
            end
        end
    end
end, "Set's PLAYERNAME's health to AMOUNT.", 3, false)

NDA.Functions.RegisterCmd({"follow"},"PLAYER1, PLAYER2",function(Speaker, Message, Parts)
    if (Parts[3] ~= nil and Parts[3] ~= "") then
        local p1 = NDA.Functions.GetPlayer(Speaker, Parts[2])
        local p2 = NDA.Functions.GetPlayer(Speaker, Parts[3])
        for i,player1 in pairs(p1) do
            if (player1.Character) ~= nil then
                local h = player1.Character:findFirstChild("Humanoid")
                if (h ~= nil) then
                    for _i,player2 in pairs(p2) do
                        if (player2.Character ~= nil) then
                            local torso = player2.Character:findFirstChild("Torso")
                            if (torso ~= nil) then
                                NDA.Data.Following = true
                                coroutine.resume(coroutine.create(function()
                                    while NDA.Data.Following do
                                        wait(.1)
                                        if torso ~= nil and h ~= nil then
                                            h:MoveTo(torso.Position, torso)
                                        else break end
                                    end
                                end))
                            end
                        end
                    end
                end
            end
        end
    end
end, "Causes PLAYER1 to constantly follow PLAYER2's character.", 3, false)

NDA.Functions.RegisterCmd({"stopfollow", "stop"},"",function() NDA.Data.Following = false
end, "Stops any players from following other players after use of the follow command.", 3, false)

NDA.Functions.RegisterCmd({"disable"},"",function(s,m,p)
    NDA.LS.Disabled = true
    NDA.LS:Destroy()
    print("LS-Com Disabled")
    NDA.Data.AB = false
    NDA.Data.ForceAB = false
    NDA.Data.Pri = false
    print("Disabled")
    script:Destroy()
    script.Disabled = true
end, "Disables this script.", 10, false)

NDA.Functions.RegisterCmd({"terrain", "placeterrain", "pt", "placet"},"X, Y, Z",function(Speaker,m,Parts)
    if (Parts[4] ~= nil and Parts[4] ~= "" and Speaker.Character ~= nil) then
        local xpos,ypos,zpos = isnumber(Parts[2]), isnumber(Parts[3]), isnumber(Parts[4])
        local t = Speaker.Character:findFirstChild("Torso")
        local b = NDA.WS:findFirstChild("Base")
        if (b ~= nil and t ~= nil and xpos and ypos and zpos) then
            if ((xpos > 40 or ypos > 40 or zpos > 40) or (xpos > 20 and ypos > 20 and zpos > 20)) then return end
            local terrain = NDA.WS.Terrain
            local material = Enum.CellMaterial.Brick --[[ Cement, MossyStone, Gravel, CinderBlock, Brick, Granite ]]
            local blocktype = Enum.CellBlock.Solid
            local orientation = Enum.CellOrientation.X
            local p,distance = t.Position,4
            --[[ base size x and z is 700 ]]

            for y = 1,ypos do
                for x = 1,xpos do
                    for z = 1,zpos do
                        terrain:SetCell((p.X + x), y - 1, ((p.Z + z) + distance), material, blocktype, orientation)
                    end
                end
            end
        end
    end
end, "Spawns a large cube of dirt terrain with the given x y and z size, near your character.", 2, false)

NDA.Functions.RegisterCmd({"classicff", "oldff", "originalff"},"PLAYERNAME, DURATION",function(Speaker, Message, Parts)
    if (Parts[3] ~= nil and Parts[3] ~= "") then
        local duration = isnumber(Parts[3])
        if duration then
            local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
            for _,v in pairs(plist) do
                if v.Character ~= nil then
                    local boxes = {}
                    for i,p in pairs(v.Character:GetChildren()) do
                        if p:IsA("BasePart") then
                            local sb = Instance.new("SelectionBox", p)
                            sb.Adornee = p
                            table.insert(boxes, sb)
                            NDA.D:AddItem(sb,duration)
                        elseif (p:IsA("Hat") and p:findFirstChild("Handle") ~= nil) then
                            local sb = Instance.new("SelectionBox", p.Handle)
                            sb.Adornee = p.Handle
                            table.insert(boxes, sb)
                            NDA.D:AddItem(sb,duration)
                        end
                    end
                    local function setc(c)
                        for _,p in pairs(boxes) do
                            p.Color = BrickColor.new(c)
                        end
                    end
                    coroutine.resume(coroutine.create(function()
                        while #boxes > 0 do
                            wait(.1)
                            setc("Really red")
                            wait(.1)
                            setc("Bright red")
                            -- wait(.1)
                            -- p.Color = BrickColor.new("Bright orange")
                            wait(.1)
                            setc("Magenta")
                            wait(.1)
                            setc("Lavender")
                            wait(.1)
                            setc("Bright blue")
                            wait(.1)
                            setc("Really blue")
                        end
                    end))
                end
            end
        end
    end
end, "Gives PLAYERNAME the original classic-looking forcefield for DURATION seconds.", 3, false)

NDA.Functions.RegisterCmd({"explode", "boom", "blowup"},"PLAYERNAME, LEVEL",function(Speaker, Message, Parts)
    if (Parts[3] ~= nil and Parts[3] ~= "") then
        local level = isnumber(Parts[3])
        if level then
            if (level >= 1 and level <= 10) then
                local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
                for _,v in pairs(plist) do
                    if v.Character ~= nil then
                        local t = v.Character:FindFirstChild("Torso")
                        if (t ~= nil) then
                            local exp = Instance.new("Explosion", NDA.WS)
                            exp.BlastPressure = math.pow(10000, level)
                            exp.BlastRadius = math.pow(1.5, level)
                            exp.Position = t.Position
                        end
                    end
                end
            end
        end
    end
end, "Explode PLAYERNAME's character with immense power based on LEVEL (a number from 1-5).", 3, false)

NDA.Functions.RegisterCmd({"clean", "clear", "cls", "clr"},"",function(s,m,_p)
    for _,v in pairs(NDA.WS:GetChildren()) do
        local class = v.ClassName
        if (v.Name ~= "NDA" and v ~= script and class ~= "Terrain" and class ~= "Camera" and v.Name ~= "Base") then
            if v.Archivable == true then
                v:Destroy()
            else
                --[[ if it's a character, search it for things to remove ]]
                local c = v:GetChildren()
                for i = 1,#c do
                    local _class = c[i].ClassName
                    local _name = c[i].Name
                    if (_class == "LocalScript" or _class == "Script" or _class == "Tool") and (_name ~= "Animate" and not _name:match("Health")) then
                        c[i]:Destroy()
                    end
                end
            end
        end
    end

    for _,object in pairs(NDA.L:GetChildren()) do
        object:Destroy()
    end

    for _,p in pairs(NDA.P:GetChildren()) do
        p:LoadCharacter()
        if p ~= s then
            destroyc(p:FindFirstChild("Backpack"))
            destroyc(p:FindFirstChild("PlayerGui"))
            destroyc(p:FindFirstChild("StarterGear"))
        end
    end
end, "Completely wipes the game of all its contents.", 5, false)

NDA.Functions.RegisterCmd({"connections", "nilp", "shownil", "nils", "showplayers", "showcon", "con", "cons"},"",function(s,m,p)
    if NDA.NS ~= nil then
        for _,child in pairs(NDA.NS:GetChildren()) do
            if (child.ClassName == "ServerReplicator") then
               if (NDA.P:FindFirstChild(tostring(child:GetPlayer())) == nil) then
                   NDA.Functions.MakeCube(s, "Really red", tostring(child:GetPlayer()).. " is nil.", nil, nil, false)
               else
                   NDA.Functions.MakeCube(s, "New Yeller", tostring(child:GetPlayer()), nil, nil, false)
               end
            end
        end
    end
end, "Shows nil players who are still connected/have their roblox window open.", 5, true)

NDA.Functions.RegisterCmd({"showlogs", "showlog", "plog", "logs", "chatlogs", "chatlog"},"PLAYERNAME",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        local plist = NDA.Functions.GetPlayer(Speaker, Parts[2])
        for _,v in pairs(plist) do
            local log = NDA.ChatLog[v.Name] or NDA.ChatLog[Parts[2]]
            if log ~= nil then
                for i = 1,#log do
                    NDA.Functions.MakeCube(Speaker, "New Yeller", log[i], nil, nil, false)
                end
            end
        end
    end
end, "Shows up to " ..NDA.Data.MaxLogs.. " most recent chat logs from PLAYERNAME.", 7, true)

NDA.Functions.RegisterCmd({"ping"},"MESSAGE",function(Speaker, Message, Parts)
    if (Parts[2] ~= nil and Parts[2] ~= "") then
        for _,v in pairs(NDA.P:GetPlayers()) do
            NDA.Functions.MakeCube(v, "New Yeller", Parts[2], 3, nil, false)
        end
    end
end, "Sends a cube to all players with the given MESSAGE.", 2, false)





--[[ END OF COMMANDS SETUP ]]
--[[ Load commands to all players ]]
--[[ Level restrictions are taken care of in the LoadCmds function ]]
for _x1,APlayer in pairs(NDA.P:GetPlayers()) do
    if APlayer.ClassName ~= "Player" then return end
    if (APlayer ~= NDA.User and APlayer.Name ~= NDA.Username) then
        NDA.Functions.SetRank(APlayer, 1)
        if NDA.Data.KickBeforePri == true then
            local pid = APlayer.userId
            local isfriend = false
            for i=1,#NDA.Friends do
                if (APlayer.Name:lower() == NDA.Friends[i]) then
                    isfriend = true
                end
            end
            for i=1,#NDA.Ranks do
                if (APlayer.Name:lower() == NDA.Ranks[i].User) then
                    isfriend = true
                end
            end
            print("is friendlisted: " ..tostring(isfriend).. ". is friend: " ..tostring(NDA.User:IsFriendsWith(pid)).. ". is best friend: " ..tostring(NDA.User:IsBestFriendsWith(pid)).. ".")
            if ((isfriend == false) and (NDA.User:IsFriendsWith(pid) == false and NDA.User:IsBestFriendsWith(pid) == false)) then
                delay(.2, function() KickPlayer(NewPlayer) end)
            end
        end
    else
        NDA.Functions.SetRank(APlayer, 10)
    end

    APlayer.Chatted:connect(function(Message)
        NDA.Functions.CheckCmds(APlayer, Message)
    end)

    for i = 1,#NDA.Banned do
        if (APlayer.Name:lower() == NDA.Banned[i]:lower()) then
            NDA.Functions.MakeCube(NDA.User, "New Yeller", APlayer.Name.. " tried to join.", 4, nil, true)
            delay(.2, function() KickPlayer(APlayer) end)
        end
    end
end


--[[ IMPORTANT EVENTS & CONNECTIONS ]]
_G.OWNER_CONNECTION_EVENT = "EVENT_NULL"
NDA.P.PlayerAdded:connect(function(NewPlayer)
    if (NewPlayer.Name ~= NDA.Username) then
        NDA.Functions.SetRank(NewPlayer, 1)
    else
        NDA.User = NewPlayer
        local con = nil
        NDA.Functions.Init()
        NDA.Functions.SetRank(NewPlayer, 10)
        con = NewPlayer.CharacterAdded:connect(function()
            NDA.Functions.MakeCube(NewPlayer, "Really blue", "Rank restored. Event: " ..OWNER_CONNECTION_EVENT, nil, nil, true)
            con:disconnect()
            con = nil
        end)
    end

    if NDA.Data.Pri == true then
        local pid = NewPlayer.userId
        local isfriend = false
        for i=1,#NDA.Friends do
            if (NewPlayer.Name:lower() == NDA.Friends[i]) then
                isfriend = true
            end
        end
        for i=1,#NDA.Ranks do
            if (NewPlayer.Name:lower() == NDA.Ranks[i].User) then
                isfriend = true
            end
        end
        print("is friendlisted: " ..tostring(isfriend).. ". is friend: " ..tostring(NDA.User:IsFriendsWith(pid)).. ". is best friend: " ..tostring(NDA.User:IsBestFriendsWith(pid)).. ".")
        if ((isfriend == false) and (NDA.User:IsFriendsWith(pid) == false and NDA.User:IsBestFriendsWith(pid) == false)) then
            delay(.2, function() KickPlayer(NewPlayer) end)
        end
    end

    NewPlayer.Chatted:connect(function(Message)
        NDA.Functions.CheckCmds(NewPlayer, Message)
    end)

    for i = 1,#NDA.Banned do
        if (NewPlayer.Name:lower() == NDA.Banned[i]:lower()) then
            NDA.Functions.MakeCube(NDA.User, "New Yeller", NewPlayer.Name.. " tried to join.", 3, nil, true)
            KickPlayer(NewPlayer)
        end
    end
end)

if not ScriptIsLocal and NDA.NS ~= nil then
    for _,v in pairs(NDA.NS:GetChildren()) do
        if (v.ClassName == "ServerReplicator") then
            if v:GetPlayer() ~= nil then
                if (NDA.P:findFirstChild(tostring(v:GetPlayer())) == nil) then
                    print("nil player found: " ..tostring(v:GetPlayer()))
                end
            end
        end
    end

    NDA.NS.ChildAdded:connect(function(con)
        if (NDA.Data.ShowTicket == true) then
            NDA.Functions.MakeCube(NDA.User, "New Yeller", "User Connecting...",2,nil,true)
            if (con.ClassName == "ServerReplicator") then
                con.TicketProcessed:connect(function(id, isauth, protocolversion)
                    local txtauth = ""
                    if isauth == true then txtauth="yes" else txtauth="no" end
                    local text = ("Ticket processed; ID: " ..id.. ". Authenticated: " ..txtauth.. ". Protocol Version: " ..protocolversion)
                    NDA.Functions.MakeCube(NDA.User, "New Yeller", text, 5, nil, true)
                end)
            end
        end
    end)

    NDA.NS.ChildRemoved:connect(function(child)
        if (child.ClassName == "ServerReplicator") then
            if (child:GetPlayer() ~= nil) then
               print(child:GetPlayer().Name.. " lost connection")
            end
        end
    end)
end

--[[ test if when I was removed my game was still open and someone kicked me, or I left, myself. ]]
NDA.P.PlayerRemoving:connect(function(Player)
    if (Player.Name:lower() == NDA.Username:lower()) then --[[ and ScriptIsLocal == false and NDA.NS ~= nil) then ]]
        if (NDA.Data.ForceAB == true) then
            NDA.Functions.ShutDown()
        end

        --[[ wait 4 seconds and check if the players connection is still there ]]
        --[[ that depicts that he was kicked from the game. Otherwise, he quit ]]
        delay(4, function()
            local a = false
            for _,v in pairs(NDA.NS:GetChildren()) do
                if (v.ClassName == "ServerReplicator") then
                    pcall(function()
                        if (v:GetPlayer().Name == NDA.Username) then
                            a = true
                        end
                    end)
                end
            end

            if a == true then
                _G.OWNER_CONNECTION_EVENT = "EVENT_KICK"
                if NDA.Data.AB == true then
                    NDA.Functions.ShutDown()
                end
            else
                _G.OWNER_CONNECTION_TEST = "EVENT_QUIT"
            end
        end)
    end
end)

NDA.WS.ChildRemoved:connect(function(child)
    if (child.Name == "CUBES") then
        NDA.Cubes = Instance.new("Model", NDA.WS)
        NDA.Cubes.Name = "CUBES"
    end
end)

--[[ allows for only 1 tool to be added but no more ]]
NDA.User.Backpack.ChildAdded:connect(function()
    if NDA.Data.AntiSpam == true then
        for _,v in pairs(NDA.User.Backpack:GetChildren()) do
            if (v.ClassName ~= "Script" and v.ClassName ~= "LocalScript") then
                v:Destroy()
            end
        end
    end
end)

NDA.User.CharacterAdded:connect(function()
    local char = NDA.User.Character
    local h = char:WaitForChild("Humanoid")
    if (h ~= nil) then
        if (NDA.Data.AutoGod == true) then
            Instance.new("ForceField", char)
            h.MaxHealth = math.huge
        end
        local function resethealth()
            h.MaxHealth = 100
            h.Health = 100
        end
        print("humanoid found")
        h.Died:connect(function()
            if NDA.Data.AntiDeath == true then
                char:MakeJoints()
                resethealth()
                char:MakeJoints()
                resethealth()
            end
        end)
        h.Changed:connect(function()
            if (NDA.Data.AntiDeath == true) then
                resethealth()
                char:MakeJoints()
            end
        end)
    end
    wait(1)
    print("AntiSpam loaded")
    NDA.User.Character.DescendantAdded:connect(function(x)
        if (NDA.Data.AntiSpam == true) then
            if (x.ClassName:match("Body")) then
                x:Destroy()
            end
        end
    end)
end)

--[[ allows for only 1 message to exist in playergui but no more ]]
NDA.User.PlayerGui.ChildAdded:connect(function(d)
    local c = NDA.User.PlayerGui:GetChildren()
    if NDA.Data.AntiSpam == true and #c > 1 then
        for _,v in pairs(c) do v:Destroy() end
    end
end)

--[[ Replace localscript if it gets removed ]]
NDA.LSDestination.DescendantRemoving:connect(function(x)
    if (x.Name == "NDA_LOCAL") then
        NDA.LS = NLS(LSSOURCE, NDA.LSDestination)
        NDA.LS.Name = "NDA_LOCAL"
    end
end)

--[[ allows for only 1 message to exist in workspace but no more ]]
NDA.WS.ChildAdded:connect(function(d)
    if (d.ClassName == "Message" or d.ClassName == "Hint") then
        local c = {}
        for i,x in pairs(NDA.WS:GetChildren()) do
            if (x.ClassName == "Message" or x.ClassName == "Hint") then
                table.insert(c, x)
            end
        end
        if NDA.Data.AntiSpam == true and #c > 1 then
            for _,v in pairs(c) do v:Destroy() end
        end
    end
end)

--[[ The Main Loop, run on a seperate thread ]]
NDA.Functions.MainLoop = function()
    if NDA.Cubes == nil then
        NDA.Cubes = Instance.new("Model", NDA.WS)
        NDS.Cubes.Name = "CUBES"
    end

    --[[ 360 / .036 = 10000!! ]]
    if NDA.Data.Rotation == true and NDA.Data.Rot < 360 then
        NDA.Data.Rot = NDA.Data.Rot + .036
    else
        NDA.Data.Rot = 0
    end

    if NDA.Data.Disco == true then
        if NDA.Data.slow_timer_1 < 4 then
            NDA.Data.slow_timer_1 = NDA.Data.slow_timer_1 + 1
        else
            NDA.Data.slow_timer_1 = 0
            NDA.L.Ambient = Color3.new(math.random(), math.random(), math.random())
        end
    end

    NDA.Data.CurrentBase = NDA.WS:findFirstChild("Base")
    if (NDA.Data.CurrentBase == nil and NDA.Data.BackupBase ~= nil) then
        NDA.Data.CurrentBase = NDA.Data.BackupBase:Clone()
        NDA.Data.CurrentBase.Parent = NDA.WS
    end

    NDA.Data.CurrentBase.FormFactor = "Custom"
    NDA.Data.CurrentBase.Size = Vector3.new(700, 1.2, 700)
    NDA.Data.CurrentBase.Anchored = true
    NDA.Data.CurrentBase.Locked = true
    NDA.Data.CurrentBase.TopSurface = 0
    NDA.Data.CurrentBase.BottomSurface = 0
    NDA.Data.CurrentBase.Name = "Base"
    NDA.Data.CurrentBase.Material = "Grass"
    NDA.Data.CurrentBase.Transparency = 0
    NDA.Data.CurrentBase.Reflectance = 0
    NDA.Data.CurrentBase.BrickColor = BrickColor.new("Bright green")
    NDA.Data.CurrentBase.CFrame = CFrame.new(0, -0.6, 0)

    local _c = NDA.Cubes:GetChildren()

    --[[ Objective:
    Sorts out the cubes by the player they follow
    and organizes them in an array.
    Then it commands which cubes follow which
    ]]
    local tab = {}

    for _,v in pairs(NDA.P:GetChildren()) do
        tab[v.Name] = {}
        tab[v.Name].Cubes = {}
        tab[v.Name].User = v
    end

    for i=1,#_c do
        local str = _c[i]:FindFirstChild("OWNER")
        if str ~= nil then
            if tab[str.Value] ~= nil then
                table.insert(tab[str.Value].Cubes, _c[i])
            end
        end
    end

    for _,v in pairs(tab) do
        local t = nil
        local c = v.Cubes
        local p = v.User
        local distance = NDA.Data.Distance + (#c * NDA.Data.Spread)

        if p ~= nil then
            if (p.ClassName == "Player") then
                if p.Character ~= nil then
                    t = p.Character:findFirstChild("Torso")

                    for i,cube in pairs(c) do
                        if t ~= nil then
                            local y = 0
                            local x = math.sin((i/#c - (NDA.Data.D/#c)) * math.pi * 2 + (NDA.Data.Rot*.1)) * distance
                            local z = math.cos((i/#c - (NDA.Data.D/#c)) * math.pi * 2 + (NDA.Data.Rot*.1)) * distance
                            --[[cube.CFrame = t.CFrame + Vector3.new(x,0,z)
                            cube.Parent = NDA.Cubes]]
                            cube.CFrame = CFrame.new(t.Position, t.Position+Vector3.new(x,y,z)) * CFrame.new(0,0,-distance) * CFrame.Angles(math.pi/2,0,0)
                        end
                    end
                end
            end
        end
    end
end

NDA.Functions.Init()
NDA.Functions.MakeCube(NDA.User, "Really blue", "NDA Loaded! v" ..NDA.Data.Version.. " - Total commands: " ..#NDA.Commands, 4.4, nil, true)
NDA.RS.Heartbeat:connect(NDA.Functions.MainLoop)