local oldWarn = warn
warn = function(...) end

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local TweenService = game:GetService("TweenService")
local UserInputService = game:GetService("UserInputService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local HttpService = game:GetService("HttpService")
local StarterPlayer = game:GetService("StarterPlayer")
local plr = Players.LocalPlayer

local VALID_KEY = "KEY39277716@dj293X67"
local KEY_URL = "https://work.ink/2grE/yorijinkey"
local CONFIG_FOLDER = "Yorijin Changer"
local SAVE_FILE = CONFIG_FOLDER .. "/YorijinChanger.json"
local KEY_FILE = CONFIG_FOLDER .. "/YorijinKey.txt"
local SPOOFER_FILE = CONFIG_FOLDER .. "/YorijinSpoofer.json"
local UNLOCK_SAVE_FILE = CONFIG_FOLDER .. "/unlockall.json"
local SELECTIVE_UNLOCK_FILE = CONFIG_FOLDER .. "/selectiveunlock.json"
local AUTOLOAD_FILE = "autoexec/YorijinAutoLoad.lua"
local DISCORD_URL = "https://discord.gg/zv8Tdmds"

pcall(function()
    if makefolder and not isfolder(CONFIG_FOLDER) then
        makefolder(CONFIG_FOLDER)
    end
end)

local keyVerified = false

local function saveKey(key)
    pcall(function() writefile(KEY_FILE, key) end)
end

local function loadSavedKey()
    local ok, result = pcall(function()
        if isfile(KEY_FILE) then return readfile(KEY_FILE) end
        return nil
    end)
    if ok and result then return result:gsub("%s+", "") end
    return nil
end

local function setupAutoLoad(enabled)
    pcall(function()
        if enabled then
            local src = 'if game.PlaceId == 17625359962 then\n'
            src = src .. '    task.wait(3)\n'
            src = src .. '    local ok, err = pcall(function()\n'
            src = src .. '        if isfile and isfile("Yorijin Changer/YorijinKey.txt") then\n'
            src = src .. '            loadstring(game:HttpGet("https://raw.githubusercontent.com/ofugii/Yorijin/refs/heads/main/rivals.lua", true))()\n'
            src = src .. '        end\n'
            src = src .. '    end)\n'
            src = src .. 'end\n'
            pcall(function() writefile(AUTOLOAD_FILE, src) end)
            pcall(function() writefile("autoexec\\YorijinAutoLoad.lua", src) end)
        else
            pcall(function() if isfile(AUTOLOAD_FILE) then writefile(AUTOLOAD_FILE, "") end end)
            pcall(function() if isfile("autoexec\\YorijinAutoLoad.lua") then writefile("autoexec\\YorijinAutoLoad.lua", "") end end)
        end
    end)
end

local savedKey = loadSavedKey()
if savedKey and savedKey == VALID_KEY then
    keyVerified = true
end

if not keyVerified then
    local function tw(obj, t, props)
        TweenService:Create(obj, TweenInfo.new(t, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), props):Play()
    end

    local kGui = Instance.new("ScreenGui")
    kGui.Name = "YorijinKey"
    kGui.ResetOnSpawn = false
    kGui.DisplayOrder = 999
    kGui.Parent = plr:WaitForChild("PlayerGui")

    local bg = Instance.new("Frame", kGui)
    bg.Size = UDim2.new(1, 0, 1, 0)
    bg.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
    bg.BackgroundTransparency = 0.3
    bg.BorderSizePixel = 0

    local win = Instance.new("Frame", kGui)
    win.Size = UDim2.new(0, 340, 0, 260)
    win.Position = UDim2.new(0.5, -170, 0.5, -130)
    win.BackgroundColor3 = Color3.fromRGB(12, 12, 12)
    win.BorderSizePixel = 0
    win.BackgroundTransparency = 1
    win.ZIndex = 2
    Instance.new("UICorner", win).CornerRadius = UDim.new(0, 10)
    local winStroke = Instance.new("UIStroke", win)
    winStroke.Color = Color3.fromRGB(30, 30, 30)
    winStroke.Thickness = 1
    winStroke.Transparency = 1

    local titleLbl = Instance.new("TextLabel", win)
    titleLbl.Size = UDim2.new(1, 0, 0, 44)
    titleLbl.BackgroundTransparency = 1
    titleLbl.Text = "Yorijin"
    titleLbl.TextColor3 = Color3.fromRGB(255, 255, 255)
    titleLbl.TextSize = 15
    titleLbl.Font = Enum.Font.GothamBold
    titleLbl.ZIndex = 3

    local inputBox = Instance.new("TextBox", win)
    inputBox.Size = UDim2.new(1, -32, 0, 42)
    inputBox.Position = UDim2.new(0, 16, 0, 50)
    inputBox.BackgroundColor3 = Color3.fromRGB(20, 20, 20)
    inputBox.Text = ""
    inputBox.PlaceholderText = "Paste key here"
    inputBox.PlaceholderColor3 = Color3.fromRGB(55, 55, 55)
    inputBox.TextColor3 = Color3.fromRGB(255, 255, 255)
    inputBox.TextSize = 13
    inputBox.Font = Enum.Font.GothamMedium
    inputBox.TextXAlignment = Enum.TextXAlignment.Left
    inputBox.ClearTextOnFocus = false
    inputBox.BorderSizePixel = 0
    inputBox.ZIndex = 3
    Instance.new("UICorner", inputBox).CornerRadius = UDim.new(0, 8)
    Instance.new("UIPadding", inputBox).PaddingLeft = UDim.new(0, 12)

    local statusLbl = Instance.new("TextLabel", win)
    statusLbl.Size = UDim2.new(1, -32, 0, 18)
    statusLbl.Position = UDim2.new(0, 16, 0, 96)
    statusLbl.BackgroundTransparency = 1
    statusLbl.Text = ""
    statusLbl.TextColor3 = Color3.fromRGB(100, 100, 100)
    statusLbl.TextSize = 11
    statusLbl.Font = Enum.Font.GothamMedium
    statusLbl.TextXAlignment = Enum.TextXAlignment.Left
    statusLbl.ZIndex = 3

    local verifyBtn = Instance.new("TextButton", win)
    verifyBtn.Size = UDim2.new(1, -32, 0, 42)
    verifyBtn.Position = UDim2.new(0, 16, 0, 120)
    verifyBtn.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
    verifyBtn.Text = "Verify"
    verifyBtn.TextColor3 = Color3.fromRGB(0, 0, 0)
    verifyBtn.TextSize = 13
    verifyBtn.Font = Enum.Font.GothamBold
    verifyBtn.BorderSizePixel = 0
    verifyBtn.ZIndex = 3
    Instance.new("UICorner", verifyBtn).CornerRadius = UDim.new(0, 8)

    verifyBtn.MouseEnter:Connect(function()
        tw(verifyBtn, 0.1, {BackgroundColor3 = Color3.fromRGB(210, 210, 210)})
    end)
    verifyBtn.MouseLeave:Connect(function()
        tw(verifyBtn, 0.1, {BackgroundColor3 = Color3.fromRGB(255, 255, 255)})
    end)

    local bottomRow = Instance.new("Frame", win)
    bottomRow.Size = UDim2.new(1, -32, 0, 34)
    bottomRow.Position = UDim2.new(0, 16, 0, 170)
    bottomRow.BackgroundTransparency = 1
    bottomRow.ZIndex = 3

    local getKeyBtn = Instance.new("TextButton", bottomRow)
    getKeyBtn.Size = UDim2.new(0.5, -4, 1, 0)
    getKeyBtn.Position = UDim2.new(0, 0, 0, 0)
    getKeyBtn.BackgroundTransparency = 1
    getKeyBtn.Text = "Get Key"
    getKeyBtn.TextColor3 = Color3.fromRGB(100, 100, 100)
    getKeyBtn.TextSize = 12
    getKeyBtn.Font = Enum.Font.GothamMedium
    getKeyBtn.BorderSizePixel = 0
    getKeyBtn.ZIndex = 3

    getKeyBtn.MouseEnter:Connect(function() getKeyBtn.TextColor3 = Color3.fromRGB(255, 255, 255) end)
    getKeyBtn.MouseLeave:Connect(function() getKeyBtn.TextColor3 = Color3.fromRGB(100, 100, 100) end)

    local discordBtn = Instance.new("TextButton", bottomRow)
    discordBtn.Size = UDim2.new(0.5, -4, 1, 0)
    discordBtn.Position = UDim2.new(0.5, 4, 0, 0)
    discordBtn.BackgroundTransparency = 1
    discordBtn.Text = "Discord"
    discordBtn.TextColor3 = Color3.fromRGB(100, 100, 100)
    discordBtn.TextSize = 12
    discordBtn.Font = Enum.Font.GothamMedium
    discordBtn.BorderSizePixel = 0
    discordBtn.ZIndex = 3

    discordBtn.MouseEnter:Connect(function() discordBtn.TextColor3 = Color3.fromRGB(255, 255, 255) end)
    discordBtn.MouseLeave:Connect(function() discordBtn.TextColor3 = Color3.fromRGB(100, 100, 100) end)

    local sep = Instance.new("Frame", win)
    sep.Size = UDim2.new(1, -32, 0, 1)
    sep.Position = UDim2.new(0, 16, 0, 212)
    sep.BackgroundColor3 = Color3.fromRGB(22, 22, 22)
    sep.BorderSizePixel = 0
    sep.ZIndex = 3

    local footLbl = Instance.new("TextLabel", win)
    footLbl.Size = UDim2.new(1, -32, 0, 40)
    footLbl.Position = UDim2.new(0, 16, 0, 218)
    footLbl.BackgroundTransparency = 1
    footLbl.Text = "Key resets every 24h"
    footLbl.TextColor3 = Color3.fromRGB(35, 35, 35)
    footLbl.TextSize = 10
    footLbl.Font = Enum.Font.Gotham
    footLbl.ZIndex = 3

    getKeyBtn.MouseButton1Click:Connect(function()
        pcall(function() setclipboard(KEY_URL) end)
        statusLbl.Text = "Link copied"
        statusLbl.TextColor3 = Color3.fromRGB(255, 255, 255)
        task.delay(2, function() statusLbl.Text = "" end)
    end)

    discordBtn.MouseButton1Click:Connect(function()
        pcall(function() setclipboard(DISCORD_URL) end)
        statusLbl.Text = "Discord link copied"
        statusLbl.TextColor3 = Color3.fromRGB(255, 255, 255)
        task.delay(0.3, function()
            pcall(function()
                if request or http_request or syn then
                    (request or http_request or syn.request)({
                        Url = "http://127.0.0.1:6463/rpc?v=1",
                        Method = "POST",
                        Headers = {["Content-Type"] = "application/json", Origin = "https://discord.com"},
                        Body = HttpService:JSONEncode({cmd = "INVITE_BROWSER", args = {code = "zv8Tdmds"}, nonce = HttpService:GenerateGUID(false)})
                    })
                end
            end)
        end)
        task.delay(2, function() statusLbl.Text = "" end)
    end)

    verifyBtn.MouseButton1Click:Connect(function()
        local entered = inputBox.Text:gsub("%s+", "")
        if entered == "" then
            statusLbl.Text = "Enter a key"
            statusLbl.TextColor3 = Color3.fromRGB(100, 100, 100)
            return
        end
        if entered == VALID_KEY then
            saveKey(entered)
            statusLbl.Text = "Verified"
            statusLbl.TextColor3 = Color3.fromRGB(255, 255, 255)
            verifyBtn.Text = "Done"
            task.delay(0.6, function()
                tw(win, 0.25, {BackgroundTransparency = 1})
                tw(winStroke, 0.25, {Transparency = 1})
                tw(bg, 0.25, {BackgroundTransparency = 1})
                task.delay(0.3, function()
                    kGui:Destroy()
                    keyVerified = true
                end)
            end)
        else
            statusLbl.Text = "Invalid key"
            statusLbl.TextColor3 = Color3.fromRGB(180, 50, 50)
            local orig = inputBox.Position
            task.spawn(function()
                for _, v in ipairs({5, -4, 3, -2, 1, 0}) do
                    inputBox.Position = UDim2.new(orig.X.Scale, orig.X.Offset + v, orig.Y.Scale, orig.Y.Offset)
                    task.wait(0.03)
                end
                inputBox.Position = orig
                task.delay(2, function() statusLbl.Text = "" end)
            end)
        end
    end)

    inputBox.FocusLost:Connect(function(enter)
        if enter then verifyBtn.MouseButton1Click:Fire() end
    end)

    task.spawn(function()
        task.wait(0.05)
        win.Position = UDim2.new(0.5, -170, 0.5, -150)
        TweenService:Create(win, TweenInfo.new(0.3, Enum.EasingStyle.Back, Enum.EasingDirection.Out), {
            BackgroundTransparency = 0,
            Position = UDim2.new(0.5, -170, 0.5, -130)
        }):Play()
        tw(winStroke, 0.3, {Transparency = 0})
    end)

    repeat task.wait(0.05) until keyVerified
end

local SkinLists = {
    ["Assault Rifle"] = {"Default","AK-47","AUG","Tommy Gun","Boneclaw Rifle","Gingerbread AUG","AKEY-47","Phoenix Rifle","10B Visits","Glorious Assault Rifle"},
    ["Bow"] = {"Default","Compound Bow","Raven Bow","Dream Bow","Bat Bow","Balloon Bow","Frostbite Bow","Beloved Bow","Key Bow","Glorious Bow"},
    ["Burst Rifle"] = {"Default","Electro Rifle","Aqua Burst","FAMAS","Spectral Burst","Pine Burst","Pixel Burst","Keyst Rifle","Glorious Burst Rifle"},
    ["Crossbow"] = {"Default","Pixel Crossbow","Harpoon Crossbow","Violin Crossbow","Frostbite Crossbow","Crossbone","Arch Crossbow","Glorious Crossbow"},
    ["Distortion"] = {"Default","Electropunk Distortion","Glorious Distortion","Experiment D15","Plasma Distortion","Magma Distortion","Sleighstortion","Cyber Distortion"},
    ["Energy Rifle"] = {"Default","Hacker Rifle","Hydro Rifle","Void Rifle","New Year Energy Rifle","Apex Rifle","Soul Rifle","Glorious Energy Rifle"},
    ["Flamethrower"] = {"Default","Pixel Flamethrower","Lamethrower","Rainbowthrower","Glitterthrower","Jack o' Thrower","Snowblower","Keythrower","Glorious Flamethrower"},
    ["Grenade Launcher"] = {"Default","Swashbuckler","Uranium Launcher","Balloon Launcher","Gearnade Launcher","Skull Launcher","Snowball Launcher","Glorious Grenade Launcher"},
    ["Gunblade"] = {"Default","Hyper Gunblade","Crude Gunblade","Gunsaw","Boneblade","Elf's Gunblade","Glorious Gunblade"},
    ["Minigun"] = {"Default","Lasergun 3000","Pixel Minigun","Fighter Jet","Pumpkin Minigun","Wrapped Minigun","Glorious Minigun"},
    ["Paintball Gun"] = {"Default","Slime Gun","Boba Gun","Paintballoon Gun","Ketchup Gun","Brain Gun","Snowball Gun","Glorious Paintball Gun"},
    ["Permafrost"] = {"Default","Snowman Permafrost","Ice Permafrost","Glorious Permafrost"},
    ["RPG"] = {"Default","Nuke Launcher","Spaceship Launcher","Squid Launcher","Pumpkin Launcher","Firework Launcher","Pencil Launcher","Rocket Launcher","RPKEY","Glorious RPG"},
    ["Shotgun"] = {"Default","Balloon Shotgun","Hyper Shotgun","Cactus Shotgun","Broomstick","Wrapped Shotgun","Shotkey","Glorious Shotgun"},
    ["Sniper"] = {"Default","Pixel Sniper","Hyper Sniper","Event Horizon","Eyething Sniper","Gingerbread Sniper","Keyper","Glorious Sniper"},
    ["Daggers"] = {"Default","Aces","Paper Planes","Shurikens","Cookies","Crystal Daggers","Broken Hearts","Bat Daggers","Keynais","Glorious Daggers"},
    ["Energy Pistols"] = {"Default","Void Pistols","Hyperlaser Guns","Hydro Pistols","Soul Pistols","Apex Pistols","Hacker Pistols","New Year Energy Pistols","Glorious Energy Pistols"},
    ["Exogun"] = {"Default","Singularity","Ray Gun","Repulsor","Wondergun","Exogourd","Midnight Festive Exogun","Glorious Exogun"},
    ["Flare Gun"] = {"Default","Firework Gun","Dynamite Gun","Banana Flare","Vexed Flare Gun","Wrapped Flare Gun","Glorious Flare Gun"},
    ["Handgun"] = {"Default","Blaster","Stealth Handgun","Gumball Handgun","Pumpkin Handgun","Towerstone Handgun","Warp Handgun","Gingerbread Handgun","Pixel Handgun","Glorious Handgun"},
    ["Revolver"] = {"Default","Desert Eagle","Sheriff","Peppergun","Boneclaw Revolver","Peppermint Sheriff","Keyvolver","Glorious Revolver"},
    ["Shorty"] = {"Default","Not So Shorty","Lovely Shorty","Balloon Shorty","Demon Shorty","Wrapped Shorty","Too Shorty","Glorious Shorty"},
    ["Slingshot"] = {"Default","Stick","Goalpost","Harp","Boneshot","Reindeer Slingshot","Lucky Horseshoe","Glorious Slingshot"},
    ["Spray"] = {"Default","Lovely Spray","Nail Gun","Spray Bottle","Boneclaw Spray","Pine Spray","Key Spray","Glorious Spray"},
    ["Uzi"] = {"Default","Water Uzi","Electro Uzi","Money Gun","Demon Uzi","Pine Uzi","Keyzi","Glorious Uzi"},
    ["Warper"] = {"Default","Glitter Warper","Arcane Warper","Hotel Bell","Experiment W4","Frost Warper","Electropunk Warper","Glorious Warper"},
    ["Battle Axe"] = {"Default","The Shred","Ban Axe","Cerulean Axe","Mimic Axe","Balloon Axe","Nordic Axe","Keyttle Axe","Glorious Battle Axe"},
    ["Chainsaw"] = {"Default","Blobsaw","Handsaws","Mega Drill","Buzzsaw","Festive Buzzsaw","Glorious Chainsaw"},
    ["Fists"] = {"Default","Boxing Gloves","Brass Knuckles","Fists of Hurt","Pumpkin Claws","Festive Fists","Fist","Glorious Fists"},
    ["Katana"] = {"Default","Saber","Lightning Bolt","Stellar Katana","Evil Trident","New Year Katana","Keytana","Arch Katana","Crystal Katana","Pixel Katana","Linked Sword","Glorious Katana"},
    ["Knife"] = {"Default","Chancla","Karambit","Armature.001","Balisong","Machete","Candy Cane","Keylisong","Keyrambit","Caladbolg","Glorious Knife"},
    ["Maul"] = {"Default","Ban Hammer","Ice Maul","Sleigh Maul","Glorious Maul"},
    ["Riot Shield"] = {"Default","Door","Energy Shield","Masterpiece","Tombstone Shield","Sled","Glorious Riot Shield"},
    ["Scythe"] = {"Default","Scythe of Death","Anchor","Bug Net","Sakura Scythe","Bat Scythe","Cryo Scythe","Crystal Scythe","Keythe","Glorious Scythe"},
    ["Trowel"] = {"Default","Plastic Shovel","Garden Shovel","Paintbrush","Pumpkin Carver","Snow Shovel","Glorious Trowel"},
    ["Flashbang"] = {"Default","Disco Ball","Camera","Pixel Flashbang","Lightbulb","Skullbang","Shining Star","Glorious Flashbang"},
    ["Freeze Ray"] = {"Default","Temporal Ray","Bubble Ray","Gum Ray","Spider Ray","Wrapped Freeze Ray","Glorious Freeze Ray"},
    ["Grenade"] = {"Default","Whoopee Cushion","Water Balloon","Dynamite","Soul Grenade","Jingle Grenade","Frozen Grenade","Cuddle Bomb","Keynade","Glorious Grenade"},
    ["Jump Pad"] = {"Default","Trampoline","Bounce House","Shady Chicken Sandwhich","Spider Web","Jolly Man","Glorious Jump Pad"},
    ["Medkit"] = {"Default","Sandwich","Laptop","Medkitty","Box of Chocolates","Bucket of Candy","Milk & Cookies","Briefcase","Glorious Medkit"},
    ["Molotov"] = {"Default","Coffee","Torch","Lava Lamp","Vexed Candle","Hot Coals","Arch Molotov","Glorious Molotov"},
    ["Satchel"] = {"Default","Advanced Satchel","Notebook Satchel","Bag o' Money","Potion Satchel","Suspicious Gift","Glorious Satchel"},
    ["Smoke Grenade"] = {"Default","Emoji Cloud","Balance","Hourglass","Eyeball","Snowglobe","Glorious Smoke Grenade"},
    ["Subspace Tripmine"] = {"Default","Don't Press","Spring","DIY Tripmine","Trick or Treat","Dev-in-the-Box","Pot o' Keys","Glorious Subspace Tripmine"},
    ["War Horn"] = {"Default","Trumpet","Megaphone","Air Horn","Boneclaw Horn","Mammoth Horn","Glorious War Horn"},
    ["Warpstone"] = {"Default","Cyber Warpstone","Teleport Disc","Electropunk Warpstone","Warpbone","Warpstar","Warpeye","Unstable Warpstone","Glorious Warpstone"},
    ["Elixir"] = {"Default"},
    ["Glass Cannon"] = {"Default"},
    ["Glast Shard"] = {"Default"},
    ["RNG Dice"] = {"Default"},
    ["Scepter"] = {"Default"},
}

local WrapList = {
    "None",
    "Beige","Blue","Bluesteel","Blush","Brown","Cheese","Cool","Copper",
    "Crimson","Cursed","Frigid","Glorious","Green","Gunmetal","Haunted",
    "Highlighter","Hot Cocoa","Jean","Lapis","Lavish Crystal","Lemon",
    "Lumber","Machine","MaGGenta","Maroon","Midnight","Mint","Mustard",
    "Navy","Noir","Normal","Olive","Olo","Orange","Ornate","Pink",
    "Pink Lemonade","Playful","Purple","Red","Rust","Salmon","Sky",
    "Sleet","Slush","Spiral","Stained","Tawny","Teal","Titanium",
    "Tungsten","Tusky","Venom","Vexed","Violet","Yellow","Zombie",
    "Ancient","Antimatter","Arbiter","Arctic Camo","Black","Black Granite",
    "Bliss","Blush Wrapping","Brain","Bunsen","Caned Wrapping",
    "Carbon Wrapping","Carmine","Carpet","Cashmere Wrapping","Celtic",
    "Cerulean","Chilled Wrapping","Chrome Webs","Circuit","Clamshell",
    "Clouds","Cold Metal","Cool Crochet","Cork","Creme Wrapping",
    "Crimson Art","Crossed","Dawn","Desert Camo","Digital Camo","Dunes",
    "Dusky Wrapping","Eco","Evergreen Wrapping","Experience","Facility",
    "Fiery","Fire","Forest Camo","Forest Wrapping","Fortune Wrapping",
    "Frosted","Frosty Wrapping","Glisten","Glossy","Gold","Grass",
    "Green Goo","Hammered Copper","Holly Wrapping","Honeycomb","Hypnotic",
    "Igneous","Indigo Wrapping","Inlets","Jolly Wrapping","Leafy Grass",
    "Liquid Chrome","Lovely Leopard","Luxury Wrapping","Mahogany",
    "Mainframe","Maize","Medium stone grey","Merlot Wrapping","Mintbread",
    "Minty Wrapping","Mocha Wrapping","Model","Money","Mousse Wrapping",
    "Neo","Nova","Obsidian","Ocean Camo","OranGG","Patriot","PB & J",
    "Pearly Wrapping","Peppermint Wrapping","Periwinkle Wrapping",
    "Pink Crochet","Pink Glitter","Plasma","Polar Wrapping","Portal",
    "Purple Goo","Purpleize","Rage","Regal","Regal Wrapping","Reptile",
    "Rug","Rustic","Scales","Sentinel","Snowfall","Spartan",
    "Spellslinger","Steel","Storm","Street Camo","Strobe","Studded",
    "Studs","Surge","Swirls","Tealur","Tempest","Termination","TIX",
    "Toy","Trophy","Ugly Sweater","Universal","Urban Camo","Vigor",
    "Vile","Voltaic","Waste","Well Done","Werewolf Fur","White",
    "Winter Solstice","Winter Wrapping","Yang","Yin",
    ".dll",".exe","2025 Wrapping","2026 Wrapping","A5","Amber",
    "Arabesque","Arena","Aurora","Aurum","Beach","Bee",
    "Birthday Wrapping","Black Damascus","Black Glass","Black Opal",
    "Blaze","Bombastic","Bright","Bubbles","Candlelight","Candy Apple",
    "Carbon Fiber","Cardboard","Cardinal","Chrome","Classic","Clovers",
    "Crystallized","Damascus","Dark","Dark Arena","Devourer","Diamond",
    "Disco","Empress","Encrypt","Fire Horse","Frankenstein","Frostbite",
    "Geometric","Gingerbread","Glass","Green Sparkle","Greenflame",
    "Groove","Hallow","Heirloom","Hesper","Hologram","Hologram Arena",
    "Honey","Hyperdrive","Indigo Sparkle","Insidious","Insignia",
    "Iridescent","Ladybug","Lightning","Liquid Gold","Lucre","Luxe",
    "Luxurious","Magma","Magnetite","Malachite","Malevolent","Mesh",
    "Messis","Mint Choco Chip","Mischief","Moonstone","Mummy","Nebula",
    "Necromancer","Omnisand","Ornamented","Paint","Peppermint","Peril",
    "Pixel Blight","Plaid Pajama","Plastic","Quasar","Red Rubber",
    "Resolute","Rift","RIVALS Wrapping","Scorched","Scourge","Serenity",
    "Shadow Ink","Simulation","Slime","Spectral","Starblaze","Starfall",
    "Stocking Fur","Sunset","Sunset Sparkle","Supernova","Thunderburst",
    "Tiger","Triplaser","Water","Watermelon","Wealth","Webbed",
    "Wintergreen","Wintry","Woven",
    "Aegis","Blizzard","Borealis","Celestial","Dark Matter","Encroached",
    "Festive Lights","Fracture","Heartfelt","Ice Queen","Neon Lights",
    "Polaris","Solar","Soul Scourge","Speed","The Heights",
    "1B Visits","Beggar","Cream","Community","Danger","Glamour",
    "Glacier","Pine","Snowy Night","Boomore","Brianore","Nekore",
    "Nosnite","Sensite","Shadore",
    "Scribble","Net","Rivalry","Only Six"
}

local CharmList = {
    "None",
    "Armchair","Bone","Bowling Pin","Cage","Candy","Candy Corn",
    "Chombie Head","Cobweb","Cog","Cookie","Crystal","Cupcake","Dice",
    "Elf Hat","Fedora Stack","Firework","Glory Coin","Hammer",
    "Happy Gingerbread","Heart","Hook","Ice Cube","Jolly Hat",
    "Lemon Slice","Life Buoy","Magnet","Mini Candy Cane",
    "Mini Shining Star","Ninja Star","Ornament","Pawn","Peppermint Candy",
    "Potted Cactus","Potted Flower","Rune Ring","Runes","Ship Wheel",
    "Snowflake","Snowflake Ring","Snowman","Spider","Star","Table Lamp",
    "Thorn Circle","Traffic Cone","Witch Hat",
    "10 Gallon Hat","Anvil","Basketball","Bitster","Blobfish",
    "Candy Bucket","Caramel Apple","Chocolate Scoop","Decorated Tree",
    "Devious Pumpkin","Emoji: Weary","Festive Light","Football",
    "Golf Ball","Gravestone","Hot Chocolate","Hotdog","Jolly Chair",
    "Melonkin","Mini Portal","Mini Unstable Portal","Moai","Money Bag",
    "Mystery Block","Potion","Pufferfish","Rainbow","Rocket Ship",
    "Rubber Duck","Snowflakes","Stocking","Tennis Ball","UFO",
    "Alien Head","Balloon Dog","Black Cat","Cauldron","Chillman",
    "Cryo Capsule","Crystal Heart","Dumbkin","Emoji: Imp",
    "Emoji: Nauseated","Emoji: Nerd","Energy Cell","Explosion",
    "Eyeclipse","EZ","First Aid","Four-Leaf Clover","Frankenblob",
    "Ghost","Gingerbread Cat","Gingerbread Man","Happy Home","Jingle Bell",
    "Keycard 3","Mini Ban Hammer","Mini Disco Ball","Mini Key",
    "Mini Snowglobe","Penguin","Pierced Heart","Pumpkin Cat","Skull",
    "Skullgourd","Sneaker","Snowblob","Warp Disc","Wreath","Yeti",
    "100M Visits","1st Birthday Cake","3D Glasses","8sty","Applino",
    "atorix","Bandites","Bell","Blizmid","BobbVX","Brian1KB",
    "Bungeoppang","CarbonMeister","Chex","D_reamz","Darktru","Day 1",
    "DV","elixir","enriquebruv","Fireplace","Frozen Gaming Chair",
    "Gaming Headset","GreatGuyBoom","Hoopie","hoppy819","Hunt Token",
    "I Survived Season 0","KaiM","Karful","Kashy","Kaye","Khayri",
    "Mega Token","Milo","Mini Present","MiniBloxia","Mud","nekoanims",
    "Nosniy","Nosniy Games","oPixel","philhood","RIA25 Award","RIVALS",
    "Season 0","Season 1","Season 2","SenseiWarrior","ShadowTrojan",
    "SharkTactics","Shooting Star","Streamer Microphone","TanqR","viecti",
    "WE1RD",
    "Alpha Coin","Coinbama","Team Crown",
    "Chibi Assault Rifle","Chibi Bow","Chibi Burst Rifle","Chibi Crossbow",
    "Chibi Energy Rifle","Chibi Flamethrower","Chibi Grenade Launcher",
    "Chibi Gunblade","Chibi Minigun","Chibi Paintball Gun","Chibi RPG",
    "Chibi Shotgun","Chibi Sniper","Chibi Daggers","Chibi Energy Pistols",
    "Chibi Exogun","Chibi Flare Gun","Chibi Handgun","Chibi Revolver",
    "Chibi Shorty","Chibi Slingshot","Chibi Spray","Chibi Uzi",
    "Chibi Warper","Chibi Battle Axe","Chibi Chainsaw","Chibi Fists",
    "Chibi Katana","Chibi Knife","Chibi Riot Shield","Chibi Scythe",
    "Chibi Trowel","Chibi Flashbang","Chibi Freeze Ray","Chibi Grenade",
    "Chibi Jump Pad","Chibi Medkit","Chibi Molotov","Chibi Satchel",
    "Chibi Smoke Grenade","Chibi Subspace Tripmine","Chibi War Horn",
    "Chibi Warpstone"
}

local FinisherList = {
    "None","Ragdoll",
    "Flop","Confetti","Hacked","Petrify","Toot","Yoink",
    "Spooky Confetti","Bite","Batsplosion","Festive Confetti","Wrapped",
    "Ascend","Bad Mood","Bogey","Bonesplosion","Collapse",
    "Decorated Player","Flick","Freeze","Frozen","Gingerbreadify",
    "Heavy Head","High Gravity","Hooked","Lost Soul","Midas Touch",
    "Reaper","Roadrunner","Rush","Snowmanify","Splatter","Tremble",
    "Warp Sickness",
    "Balloons","Beacon","BONK!","Boogie","Broom Ride","Chark Attack",
    "Clapped","Crushed","Darkheart","David","Dematerialize",
    "Diamond Hands","Disintegrate","DRIP","Electrocute","Enlightened",
    "Erased","Falling Icicles","Firework Show","Giant Ice Spike",
    "Giant Snowball","GOOAAALLLL","Greenflame","Heartbeat","Ignite",
    "Impaled","Inflate","Instability","Leprechaunify","Low Gravity","OOF",
    "Opulent","Orbital Strike","Pixel Coins","Plushify","Poof",
    "Rainbow Barf","RIP","Sleigh Away","Snowballed","Spaghettified",
    "Stiff","Those Who Know","Tough Crowd","Zombified",
    "5B Visits","Director's Cut","Elfify","Jolly Judgement"
}

local AllSkinNames = {}
do
    local seen = {}
    for _, skins in pairs(SkinLists) do
        for _, s in ipairs(skins) do
            if s ~= "Default" and not seen[s] then
                seen[s] = true
                table.insert(AllSkinNames, s)
            end
        end
    end
    table.sort(AllSkinNames)
end

local PlayerScripts = plr:WaitForChild("PlayerScripts")
local Controllers = PlayerScripts:WaitForChild("Controllers")
local PlayerDataController = require(Controllers:WaitForChild("PlayerDataController", 10))

repeat task.wait() until PlayerDataController.CurrentData
local PlayerData = PlayerDataController.CurrentData

local CosmeticLibrary = require(ReplicatedStorage.Modules.CosmeticLibrary)
local EnumLibrary = require(ReplicatedStorage.Modules:WaitForChild("EnumLibrary", 10))

local ItemLibrary
pcall(function()
    ItemLibrary = require(ReplicatedStorage.Modules.ItemLibrary)
end)

local cosmeticConfig = {}
pcall(function()
    if readfile and isfile and isfile(SAVE_FILE) then
        cosmeticConfig = HttpService:JSONDecode(readfile(SAVE_FILE))
    end
end)

local function saveConfig()
    pcall(function()
        if writefile then
            writefile(SAVE_FILE, HttpService:JSONEncode(cosmeticConfig))
        end
    end)
end

_G.GlobalData = _G.GlobalData or {AutoLoad = false, SilentLoad = false}
if cosmeticConfig._global then
    _G.GlobalData.AutoLoad = cosmeticConfig._global.AutoLoad or false
    _G.GlobalData.SilentLoad = cosmeticConfig._global.SilentLoad or false
end

local function saveGlobalToConfig()
    cosmeticConfig._global = {
        AutoLoad = _G.GlobalData.AutoLoad,
        SilentLoad = _G.GlobalData.SilentLoad,
    }
    saveConfig()
end

setupAutoLoad(_G.GlobalData.AutoLoad)

local function waitForAssets(timeout)
    local start = tick()
    local assetsFolder, charmsFolder
    while tick() - start < (timeout or 10) do
        pcall(function()
            local ps = plr:FindFirstChild("PlayerScripts")
            if ps then
                assetsFolder = ps:FindFirstChild("Assets")
                if assetsFolder then
                    charmsFolder = assetsFolder:FindFirstChild("Charms")
                end
            end
        end)
        if assetsFolder and charmsFolder then
            return assetsFolder, charmsFolder
        end
        task.wait(0.1)
    end
    return assetsFolder, charmsFolder
end

local AssetsFolder, CharmsFolder = waitForAssets(15)

if not CharmsFolder then
    pcall(function()
        local sps = StarterPlayer:WaitForChild("StarterPlayerScripts", 5)
        if sps then
            local af = sps:FindFirstChild("Assets")
            if af then
                CharmsFolder = af:FindFirstChild("Charms")
            end
        end
    end)
end

local SkinImageIds = {}

local function buildSkinImageMap()
    pcall(function()
        for name, data in pairs(CosmeticLibrary.Cosmetics) do
            if type(data) == "table" then
                local img = data.Icon or data.Image or data.Thumbnail or data.ImageId or data.TextureId
                if img and type(img) == "string" and img ~= "" then
                    SkinImageIds[name] = img
                end
            end
        end
    end)
    pcall(function()
        local folders = {"ViewModels", "Assets", "Weapons", "Cosmetics", "CosmeticModels", "Icons", "SkinIcons", "ItemIcons"}
        for _, folderName in ipairs(folders) do
            local folder = ReplicatedStorage:FindFirstChild(folderName)
            if folder then
                for _, desc in pairs(folder:GetDescendants()) do
                    if desc:IsA("Decal") or desc:IsA("Texture") then
                        local skinName = desc.Parent and desc.Parent.Name
                        if skinName and desc.Texture ~= "" and not SkinImageIds[skinName] then
                            SkinImageIds[skinName] = desc.Texture
                        end
                    elseif desc:IsA("MeshPart") and desc.TextureID ~= "" then
                        if not SkinImageIds[desc.Name] then
                            SkinImageIds[desc.Name] = desc.TextureID
                        end
                    elseif (desc:IsA("ImageLabel") or desc:IsA("ImageButton")) and desc.Image ~= "" then
                        if not SkinImageIds[desc.Name] then
                            SkinImageIds[desc.Name] = desc.Image
                        end
                    end
                end
            end
        end
    end)
    pcall(function()
        if ItemLibrary then
            for weaponName in pairs(SkinLists) do
                pcall(function()
                    local img = ItemLibrary:GetViewModelImage(weaponName)
                    if img and img ~= "" and not SkinImageIds[weaponName] then
                        SkinImageIds[weaponName] = img
                    end
                end)
            end
        end
    end)
end

buildSkinImageMap()

local function getSkinImage(skinName)
    if SkinImageIds[skinName] then return SkinImageIds[skinName] end
    if ItemLibrary then
        local ok, img = pcall(function() return ItemLibrary:GetViewModelImage(skinName) end)
        if ok and img and img ~= "" then
            SkinImageIds[skinName] = img
            return img
        end
    end
    return ""
end

local function cloneCosmetic(name, cosmeticType)
    if not name or name:lower() == "none" or name == "Default" then return nil end

    local base = CosmeticLibrary.Cosmetics[name]
    local data = {}

    if base then
        for k, v in pairs(base) do data[k] = v end
    end

    data.Name = name
    data.Type = cosmeticType
    data.Seed = data.Seed or math.random(1, 1000000)

    pcall(function()
        if EnumLibrary then
            local e = EnumLibrary:ToEnum(name)
            if e then
                data.Enum = e
                data.ObjectID = e
            end
        end
    end)

    if not base then
        pcall(function()
            for _, obj in pairs(getgc(true)) do
                if type(obj) == "table" and rawget(obj, name) and type(rawget(obj, name)) == "table" then
                    local candidate = rawget(obj, name)
                    if candidate.Type == cosmeticType or candidate.Name == name then
                        for k, v in pairs(candidate) do
                            if data[k] == nil then
                                data[k] = v
                            end
                        end
                        break
                    end
                end
            end
        end)
    end

    return data
end

local function findWeaponEntry(weaponName)
    local weaponInventory = PlayerData:Get("WeaponInventory")
    if not weaponInventory then return nil end
    for _, weaponEntry in pairs(weaponInventory) do
        if weaponEntry.Name == weaponName then
            return weaponEntry
        end
    end
    return nil
end

local function injectWeaponData(weaponName)
    local weaponInventory = PlayerData:Get("WeaponInventory")
    if not weaponInventory then return end

    local cfg = cosmeticConfig[weaponName]
    if not cfg then return end

    local weaponEntry = findWeaponEntry(weaponName)
    if not weaponEntry then return end

    weaponEntry.Skin = cfg.Skin
    weaponEntry.Wrap = cfg.Wrap
    weaponEntry.Charm = cfg.Charm
    weaponEntry.Finisher = cfg.Finisher
    return weaponEntry
end

local function injectActiveWeapon()
    local ok, FighterController = pcall(function()
        return require(Controllers:WaitForChild("FighterController", 10))
    end)
    if not ok then return end

    local fighter = FighterController:GetFighter(plr)
    if not fighter or not fighter.Items then return end

    for _, item in pairs(fighter.Items) do
        local weaponName = item.Name
        if cosmeticConfig[weaponName] then
            local cfg = cosmeticConfig[weaponName]
            pcall(function()
                if cfg.Skin then item:Set("Skin", cfg.Skin) end
                if cfg.Wrap then item:Set("Wrap", cfg.Wrap) end
                if cfg.Charm then item:Set("Charm", cfg.Charm) end
                if cfg.Finisher then item:Set("Finisher", cfg.Finisher) end

                if item._ViewModel then
                    local vm = item._ViewModel
                    if cfg.Skin and vm.SetSkin then vm:SetSkin(cfg.Skin) end
                    if cfg.Wrap and vm.SetWrap then vm:SetWrap(cfg.Wrap) end
                    if cfg.Charm and vm.SetCharm then vm:SetCharm(cfg.Charm) end
                    if vm._UpdateSkin then vm:_UpdateSkin() end
                    if vm._UpdateWrap then vm:_UpdateWrap() end
                    if vm._UpdateCharm then vm:_UpdateCharm() end
                end
            end)
        end
    end
end

pcall(function()
    local ClientItem = require(PlayerScripts.Modules.ClientReplicatedClasses.ClientFighter.ClientItem)
    local original_CreateViewModel = ClientItem._CreateViewModel

    ClientItem._CreateViewModel = function(self, replicatedData)
        local weaponName = self.Name
        local ownerPlayer = self.ClientFighter and self.ClientFighter.Player

        if ownerPlayer == plr and cosmeticConfig[weaponName] then
            local cfg = cosmeticConfig[weaponName]
            if not replicatedData then replicatedData = {} end

            if cfg.Skin then
                pcall(function()
                    if replicatedData.Data then
                        replicatedData.Data.Skin = cfg.Skin
                        replicatedData.Data.Name = cfg.Skin.Name
                    else
                        local RepClass = require(ReplicatedStorage.Modules.ReplicatedClass)
                        local dataKey = RepClass:ToEnum("Data")
                        local skinKey = RepClass:ToEnum("Skin")
                        local nameKey = RepClass:ToEnum("Name")

                        if replicatedData[dataKey] then
                            replicatedData[dataKey][skinKey] = cfg.Skin
                            replicatedData[dataKey][nameKey] = cfg.Skin.Name
                        end
                    end
                end)
            end
        end

        return original_CreateViewModel(self, replicatedData)
    end
end)

pcall(function()
    local vmModule = PlayerScripts.Modules.ClientReplicatedClasses.ClientFighter.ClientItem:FindFirstChild("ClientViewModel")
    if not vmModule then return end

    local ClientViewModel = require(vmModule)

    local originalGetWrap = ClientViewModel.GetWrap
    ClientViewModel.GetWrap = function(self)
        local clientItem = self.ClientItem
        if not clientItem then return originalGetWrap(self) end

        local weaponName = clientItem.Name
        local ownerPlayer = clientItem.ClientFighter and clientItem.ClientFighter.Player

        if ownerPlayer == plr and cosmeticConfig[weaponName] and cosmeticConfig[weaponName].Wrap then
            return cosmeticConfig[weaponName].Wrap
        end
        return originalGetWrap(self)
    end

    local originalNew = ClientViewModel.new
    ClientViewModel.new = function(replicatedData, clientItem)
        if not clientItem then return originalNew(replicatedData, clientItem) end

        local ownerPlayer = clientItem.ClientFighter and clientItem.ClientFighter.Player
        local weaponName = clientItem.Name

        if ownerPlayer == plr and cosmeticConfig[weaponName] then
            pcall(function()
                local RepClass = require(ReplicatedStorage.Modules.ReplicatedClass)
                local dataKey = RepClass:ToEnum("Data")

                replicatedData[dataKey] = replicatedData[dataKey] or {}
                local cfg = cosmeticConfig[weaponName]

                if cfg.Skin then replicatedData[dataKey][RepClass:ToEnum("Skin")] = cfg.Skin end
                if cfg.Wrap then replicatedData[dataKey][RepClass:ToEnum("Wrap")] = cfg.Wrap end
                if cfg.Charm then replicatedData[dataKey][RepClass:ToEnum("Charm")] = cfg.Charm end
            end)
        end

        local vm = originalNew(replicatedData, clientItem)

        if vm and ownerPlayer == plr and cosmeticConfig[weaponName] then
            local cfg = cosmeticConfig[weaponName]
            pcall(function()
                if cfg.Wrap and vm._UpdateWrap then vm:_UpdateWrap() end
                if cfg.Skin and vm._UpdateSkin then vm:_UpdateSkin() end
            end)
        end

        return vm
    end
end)

local function equipCosmetic(weaponName, cosmeticType, cosmeticName)
    if cosmeticName == "None" or cosmeticName == "Default" then
        if cosmeticConfig[weaponName] then
            cosmeticConfig[weaponName][cosmeticType] = nil
            local hasKeys = false
            for k, _ in pairs(cosmeticConfig[weaponName]) do
                hasKeys = true
                break
            end
            if not hasKeys then
                cosmeticConfig[weaponName] = nil
            end
        end
        if findWeaponEntry(weaponName) then
            injectWeaponData(weaponName)
        end
        injectActiveWeapon()
        saveConfig()
        pcall(function() PlayerData:Replicate("WeaponInventory") end)
        return
    end

    local cloned = cloneCosmetic(cosmeticName, cosmeticType)
    if not cloned then return end

    if not cosmeticConfig[weaponName] then
        cosmeticConfig[weaponName] = {}
    end

    cosmeticConfig[weaponName][cosmeticType] = cloned

    if findWeaponEntry(weaponName) then
        injectWeaponData(weaponName)
    end

    injectActiveWeapon()
    saveConfig()

    pcall(function() PlayerData:Replicate("WeaponInventory") end)
end

local function applyWrapToAll(wrapName)
    for weapon in pairs(SkinLists) do
        if wrapName == "None" then
            if cosmeticConfig[weapon] then
                cosmeticConfig[weapon].Wrap = nil
                local hasKeys = false
                for k, _ in pairs(cosmeticConfig[weapon]) do
                    hasKeys = true
                    break
                end
                if not hasKeys then
                    cosmeticConfig[weapon] = nil
                end
            end
        else
            local cloned = cloneCosmetic(wrapName, "Wrap")
            if cloned then
                if not cosmeticConfig[weapon] then cosmeticConfig[weapon] = {} end
                cosmeticConfig[weapon].Wrap = cloned
            end
        end
        if findWeaponEntry(weapon) then
            injectWeaponData(weapon)
        end
    end
    injectActiveWeapon()
    saveConfig()
    pcall(function() PlayerData:Replicate("WeaponInventory") end)
end

local _unlockAllApplied = false

local function unlockAllCosmetics()
    if _unlockAllApplied then return end
    _unlockAllApplied = true

    local _player = plr
    local _playerScripts = _player:WaitForChild("PlayerScripts")
    local _controllers = _playerScripts:WaitForChild("Controllers")

    local _EnumLibrary = require(ReplicatedStorage.Modules:WaitForChild("EnumLibrary", 10))
    if _EnumLibrary then _EnumLibrary:WaitForEnumBuilder() end
    local _CosmeticLibrary = require(ReplicatedStorage.Modules:WaitForChild("CosmeticLibrary", 10))
    local _ItemLibrary = require(ReplicatedStorage.Modules:WaitForChild("ItemLibrary", 10))
    local _DataController = require(_controllers:WaitForChild("PlayerDataController", 10))

    local _equipped, _favorites = {}, {}
    local _constructingWeapon, _viewingProfile = nil, nil
    local _lastUsedWeapon = nil

    local function _cloneCosmetic(name, cosmeticType, options)
        local base = _CosmeticLibrary.Cosmetics[name]
        if not base then return nil end
        local data = {}
        for key, value in pairs(base) do data[key] = value end
        data.Name = name
        data.Type = data.Type or cosmeticType
        data.Seed = data.Seed or math.random(1, 1000000)
        if _EnumLibrary then
            local success, enumId = pcall(_EnumLibrary.ToEnum, _EnumLibrary, name)
            if success and enumId then data.Enum, data.ObjectID = enumId, data.ObjectID or enumId end
        end
        if options then
            if options.inverted ~= nil then data.Inverted = options.inverted end
            if options.favoritesOnly ~= nil then data.OnlyUseFavorites = options.favoritesOnly end
        end
        return data
    end

    local function _saveConfig()
        if not writefile then return end
        pcall(function()
            local config = {equipped = {}, favorites = _favorites}
            for weapon, cosmetics in pairs(_equipped) do
                config.equipped[weapon] = {}
                for cosmeticType, cosmeticData in pairs(cosmetics) do
                    if cosmeticData and cosmeticData.Name then
                        config.equipped[weapon][cosmeticType] = {
                            name = cosmeticData.Name, seed = cosmeticData.Seed, inverted = cosmeticData.Inverted
                        }
                    end
                end
            end
            writefile(UNLOCK_SAVE_FILE, HttpService:JSONEncode(config))
        end)
    end

    local function _loadConfig()
        if not readfile or not isfile or not isfile(UNLOCK_SAVE_FILE) then return end
        pcall(function()
            local config = HttpService:JSONDecode(readfile(UNLOCK_SAVE_FILE))
            if config.equipped then
                for weapon, cosmetics in pairs(config.equipped) do
                    _equipped[weapon] = {}
                    for cosmeticType, cosmeticData in pairs(cosmetics) do
                        local cloned = _cloneCosmetic(cosmeticData.name, cosmeticType, {inverted = cosmeticData.inverted})
                        if cloned then cloned.Seed = cosmeticData.seed _equipped[weapon][cosmeticType] = cloned end
                    end
                end
            end
            _favorites = config.favorites or {}
        end)
    end

    _CosmeticLibrary.OwnsCosmeticNormally = function() return true end
    _CosmeticLibrary.OwnsCosmeticUniversally = function() return true end
    _CosmeticLibrary.OwnsCosmeticForWeapon = function() return true end
    local _originalOwnsCosmetic = _CosmeticLibrary.OwnsCosmetic
    _CosmeticLibrary.OwnsCosmetic = function(self, inventory, name, weapon)
        if name:find("MISSING_") then return _originalOwnsCosmetic(self, inventory, name, weapon) end
        return true
    end

    local _originalGet = _DataController.Get
    _DataController.Get = function(self, key)
        local data = _originalGet(self, key)
        if key == "CosmeticInventory" then
            local proxy = {}
            if data then for k, v in pairs(data) do proxy[k] = v end end
            return setmetatable(proxy, {__index = function() return true end})
        end
        if key == "FavoritedCosmetics" then
            local result = data and table.clone(data) or {}
            for weapon, favs in pairs(_favorites) do
                result[weapon] = result[weapon] or {}
                for name, isFav in pairs(favs) do result[weapon][name] = isFav end
            end
            return result
        end
        return data
    end

    local _originalGetWeaponData = _DataController.GetWeaponData
    _DataController.GetWeaponData = function(self, weaponName)
        local data = _originalGetWeaponData(self, weaponName)
        if not data then return nil end

        local merged = {}
        for key, value in pairs(data) do merged[key] = value end
        merged.Name = weaponName
        if _equipped[weaponName] then
            for cosmeticType, cosmeticData in pairs(_equipped[weaponName]) do merged[cosmeticType] = cosmeticData end
        end
        return merged
    end

    local _FighterController
    pcall(function() _FighterController = require(_controllers:WaitForChild("FighterController", 10)) end)

    if hookmetamethod then
        local remotes = ReplicatedStorage:FindFirstChild("Remotes")
        local dataRemotes = remotes and remotes:FindFirstChild("Data")
        local equipRemote = dataRemotes and dataRemotes:FindFirstChild("EquipCosmetic")
        local favoriteRemote = dataRemotes and dataRemotes:FindFirstChild("FavoriteCosmetic")
        local replicationRemotes = remotes and remotes:FindFirstChild("Replication")
        local fighterRemotes = replicationRemotes and replicationRemotes:FindFirstChild("Fighter")
        local useItemRemote = fighterRemotes and fighterRemotes:FindFirstChild("UseItem")

        if equipRemote then
            local oldNamecall
            oldNamecall = hookmetamethod(game, "__namecall", function(self, ...)
                if getnamecallmethod() ~= "FireServer" then return oldNamecall(self, ...) end
                local args = {...}

                if useItemRemote and self == useItemRemote then
                    local objectID = args[1]
                    if _FighterController then
                        pcall(function()
                            local fighter = _FighterController:GetFighter(_player)
                            if fighter and fighter.Items then
                                for _, item in pairs(fighter.Items) do
                                    if item:Get("ObjectID") == objectID then
                                        _lastUsedWeapon = item.Name
                                        break
                                    end
                                end
                            end
                        end)
                    end
                end

                if self == equipRemote then
                    local weaponName, cosmeticType, cosmeticName, options = args[1], args[2], args[3], args[4] or {}

                    if cosmeticName and cosmeticName ~= "None" and cosmeticName ~= "" then
                        local inventory = _DataController:Get("CosmeticInventory")
                        if inventory and rawget(inventory, cosmeticName) then return oldNamecall(self, ...) end
                    end

                    _equipped[weaponName] = _equipped[weaponName] or {}

                    if not cosmeticName or cosmeticName == "None" or cosmeticName == "" then
                        _equipped[weaponName][cosmeticType] = nil
                        if not next(_equipped[weaponName]) then _equipped[weaponName] = nil end
                    else
                        local cloned = _cloneCosmetic(cosmeticName, cosmeticType, {inverted = options.IsInverted, favoritesOnly = options.OnlyUseFavorites})
                        if cloned then _equipped[weaponName][cosmeticType] = cloned end
                    end

                    task.defer(function()
                        pcall(function() _DataController.CurrentData:Replicate("WeaponInventory") end)
                        task.wait(0.2)
                        _saveConfig()
                    end)
                    return
                end

                if self == favoriteRemote then
                    _favorites[args[1]] = _favorites[args[1]] or {}
                    _favorites[args[1]][args[2]] = args[3] or nil
                    _saveConfig()
                    task.spawn(function() pcall(function() _DataController.CurrentData:Replicate("FavoritedCosmetics") end) end)
                    return
                end

                return oldNamecall(self, ...)
            end)
        end
    end

    local _ClientItem
    pcall(function() _ClientItem = require(_player.PlayerScripts.Modules.ClientReplicatedClasses.ClientFighter.ClientItem) end)
    if _ClientItem and _ClientItem._CreateViewModel then
        local _originalCreateViewModel = _ClientItem._CreateViewModel
        _ClientItem._CreateViewModel = function(self, viewmodelRef)
            local weaponName = self.Name
            local weaponPlayer = self.ClientFighter and self.ClientFighter.Player
            _constructingWeapon = (weaponPlayer == _player) and weaponName or nil

            if weaponPlayer == _player and _equipped[weaponName] and _equipped[weaponName].Skin and viewmodelRef then
                local dataKey, skinKey, nameKey = self:ToEnum("Data"), self:ToEnum("Skin"), self:ToEnum("Name")
                if viewmodelRef[dataKey] then
                    viewmodelRef[dataKey][skinKey] = _equipped[weaponName].Skin
                    viewmodelRef[dataKey][nameKey] = _equipped[weaponName].Skin.Name
                elseif viewmodelRef.Data then
                    viewmodelRef.Data.Skin = _equipped[weaponName].Skin
                    viewmodelRef.Data.Name = _equipped[weaponName].Skin.Name
                end
            end

            local result = _originalCreateViewModel(self, viewmodelRef)
            _constructingWeapon = nil
            return result
        end
    end

    local _viewModelModule = _player.PlayerScripts.Modules.ClientReplicatedClasses.ClientFighter.ClientItem:FindFirstChild("ClientViewModel")
    if _viewModelModule then
        local _ClientViewModel = require(_viewModelModule)
        if _ClientViewModel.GetWrap then
            local _originalGetWrap = _ClientViewModel.GetWrap
            _ClientViewModel.GetWrap = function(self)
                local weaponName = self.ClientItem and self.ClientItem.Name
                local weaponPlayer = self.ClientItem and self.ClientItem.ClientFighter and self.ClientItem.ClientFighter.Player
                if weaponName and weaponPlayer == _player and _equipped[weaponName] and _equipped[weaponName].Wrap then
                    return _equipped[weaponName].Wrap
                end
                return _originalGetWrap(self)
            end
        end
        local _originalNew = _ClientViewModel.new
        _ClientViewModel.new = function(replicatedData, clientItem)
            local weaponPlayer = clientItem.ClientFighter and clientItem.ClientFighter.Player
            local weaponName = _constructingWeapon or clientItem.Name
            if weaponPlayer == _player and _equipped[weaponName] then
                local ReplicatedClass = require(ReplicatedStorage.Modules.ReplicatedClass)
                local dataKey = ReplicatedClass:ToEnum("Data")
                replicatedData[dataKey] = replicatedData[dataKey] or {}
                local cosmetics = _equipped[weaponName]
                if cosmetics.Skin then replicatedData[dataKey][ReplicatedClass:ToEnum("Skin")] = cosmetics.Skin end
                if cosmetics.Wrap then replicatedData[dataKey][ReplicatedClass:ToEnum("Wrap")] = cosmetics.Wrap end
                if cosmetics.Charm then replicatedData[dataKey][ReplicatedClass:ToEnum("Charm")] = cosmetics.Charm end
            end
            local result = _originalNew(replicatedData, clientItem)
            if weaponPlayer == _player and _equipped[weaponName] and _equipped[weaponName].Wrap and result._UpdateWrap then
                result:_UpdateWrap()
                task.delay(0.1, function() if not result._destroyed then result:_UpdateWrap() end end)
            end
            return result
        end
    end

    if _ItemLibrary and _ItemLibrary.GetViewModelImageFromWeaponData then
        local _originalGetViewModelImage = _ItemLibrary.GetViewModelImageFromWeaponData
        _ItemLibrary.GetViewModelImageFromWeaponData = function(self, weaponData, highRes)
            if not weaponData then return _originalGetViewModelImage(self, weaponData, highRes) end
            local weaponName = weaponData.Name
            local shouldShowSkin = (weaponData.Skin and _equipped[weaponName] and weaponData.Skin == _equipped[weaponName].Skin) or (_viewingProfile == _player and _equipped[weaponName] and _equipped[weaponName].Skin)
            if shouldShowSkin and _equipped[weaponName] and _equipped[weaponName].Skin then
                local skinInfo = self.ViewModels[_equipped[weaponName].Skin.Name]
                if skinInfo then return skinInfo[highRes and "ImageHighResolution" or "Image"] or skinInfo.Image end
            end
            return _originalGetViewModelImage(self, weaponData, highRes)
        end
    end

    pcall(function()
        local ViewProfile = require(_player.PlayerScripts.Modules.Pages.ViewProfile)
        if ViewProfile and ViewProfile.Fetch then
            local _originalFetch = ViewProfile.Fetch
            ViewProfile.Fetch = function(self, targetPlayer)
                _viewingProfile = targetPlayer
                return _originalFetch(self, targetPlayer)
            end
        end
    end)

    local _ClientEntity
    pcall(function() _ClientEntity = require(_player.PlayerScripts.Modules.ClientReplicatedClasses.ClientEntity) end)
    if _ClientEntity and _ClientEntity.ReplicateFromServer then
        local _originalReplicateFromServer = _ClientEntity.ReplicateFromServer
        _ClientEntity.ReplicateFromServer = function(self, action, ...)
            if action == "FinisherEffect" then
                local args = {...}
                local killerName = args[3]
                local decodedKiller = killerName
                if type(killerName) == "userdata" and _EnumLibrary and _EnumLibrary.FromEnum then
                    local ok, decoded = pcall(_EnumLibrary.FromEnum, _EnumLibrary, killerName)
                    if ok and decoded then decodedKiller = decoded end
                end
                local isOurKill = tostring(decodedKiller) == _player.Name or tostring(decodedKiller):lower() == _player.Name:lower()
                if isOurKill and _lastUsedWeapon and _equipped[_lastUsedWeapon] and _equipped[_lastUsedWeapon].Finisher then
                    local finisherData = _equipped[_lastUsedWeapon].Finisher
                    local finisherEnum = finisherData.Enum
                    if not finisherEnum and _EnumLibrary then
                        local ok, result = pcall(_EnumLibrary.ToEnum, _EnumLibrary, finisherData.Name)
                        if ok and result then finisherEnum = result end
                    end
                    if finisherEnum then
                        args[1] = finisherEnum
                        return _originalReplicateFromServer(self, action, unpack(args))
                    end
                end
            end
            return _originalReplicateFromServer(self, action, ...)
        end
    end

    _loadConfig()
end

local _selectiveUnlockApplied = false
local _selectiveUnlockedItems = {}
local _selectiveEquipped = {}
local _selectiveFavorites = {}
local _selectiveLastUsedWeapon = nil

local function _saveSelectiveConfig()
    if not writefile then return end
    pcall(function()
        local config = {equipped = {}, favorites = _selectiveFavorites, unlocked = {}}
        for name, _ in pairs(_selectiveUnlockedItems) do
            config.unlocked[name] = true
        end
        for weapon, cosmetics in pairs(_selectiveEquipped) do
            config.equipped[weapon] = {}
            for cosmeticType, cosmeticData in pairs(cosmetics) do
                if cosmeticData and cosmeticData.Name then
                    config.equipped[weapon][cosmeticType] = {
                        name = cosmeticData.Name, seed = cosmeticData.Seed, inverted = cosmeticData.Inverted
                    }
                end
            end
        end
        writefile(SELECTIVE_UNLOCK_FILE, HttpService:JSONEncode(config))
    end)
end

local function _loadSelectiveConfig()
    if not readfile or not isfile or not isfile(SELECTIVE_UNLOCK_FILE) then return end
    pcall(function()
        local _CosmeticLibrary = require(ReplicatedStorage.Modules:WaitForChild("CosmeticLibrary", 10))
        local _EnumLibrary = require(ReplicatedStorage.Modules:WaitForChild("EnumLibrary", 10))
        local config = HttpService:JSONDecode(readfile(SELECTIVE_UNLOCK_FILE))
        if config.unlocked then
            for name, _ in pairs(config.unlocked) do
                _selectiveUnlockedItems[name] = true
            end
        end
        if config.equipped then
            for weapon, cosmetics in pairs(config.equipped) do
                _selectiveEquipped[weapon] = {}
                for cosmeticType, cosmeticData in pairs(cosmetics) do
                    local base = _CosmeticLibrary.Cosmetics[cosmeticData.name]
                    if base then
                        local data = {}
                        for key, value in pairs(base) do data[key] = value end
                        data.Name = cosmeticData.name
                        data.Type = data.Type or cosmeticType
                        data.Seed = cosmeticData.seed or math.random(1, 1000000)
                        if cosmeticData.inverted ~= nil then data.Inverted = cosmeticData.inverted end
                        if _EnumLibrary then
                            local success, enumId = pcall(_EnumLibrary.ToEnum, _EnumLibrary, cosmeticData.name)
                            if success and enumId then data.Enum = enumId data.ObjectID = data.ObjectID or enumId end
                        end
                        _selectiveEquipped[weapon][cosmeticType] = data
                    end
                end
            end
        end
        _selectiveFavorites = config.favorites or {}
    end)
end

local function unlockSelectiveCosmetics(selectedSkins, selectedWraps, selectedCharms, selectedFinishers)
    local _player = plr
    local _playerScripts = _player:WaitForChild("PlayerScripts")
    local _controllers = _playerScripts:WaitForChild("Controllers")

    local _EnumLibrary = require(ReplicatedStorage.Modules:WaitForChild("EnumLibrary", 10))
    if _EnumLibrary then _EnumLibrary:WaitForEnumBuilder() end
    local _CosmeticLibrary = require(ReplicatedStorage.Modules:WaitForChild("CosmeticLibrary", 10))
    local _ItemLibrary = require(ReplicatedStorage.Modules:WaitForChild("ItemLibrary", 10))
    local _DataController = require(_controllers:WaitForChild("PlayerDataController", 10))

    local unlockSet = {}
    if selectedSkins then
        for _, name in ipairs(selectedSkins) do
            unlockSet[name] = true
        end
    end
    if selectedWraps then
        for _, name in ipairs(selectedWraps) do
            unlockSet[name] = true
        end
    end
    if selectedCharms then
        for _, name in ipairs(selectedCharms) do
            unlockSet[name] = true
        end
    end
    if selectedFinishers then
        for _, name in ipairs(selectedFinishers) do
            unlockSet[name] = true
        end
    end

    for name, _ in pairs(unlockSet) do
        _selectiveUnlockedItems[name] = true
    end

    local function _selCloneCosmetic(name, cosmeticType, options)
        local base = _CosmeticLibrary.Cosmetics[name]
        if not base then return nil end
        local data = {}
        for key, value in pairs(base) do data[key] = value end
        data.Name = name
        data.Type = data.Type or cosmeticType
        data.Seed = data.Seed or math.random(1, 1000000)
        if _EnumLibrary then
            local success, enumId = pcall(_EnumLibrary.ToEnum, _EnumLibrary, name)
            if success and enumId then data.Enum = enumId data.ObjectID = data.ObjectID or enumId end
        end
        if options then
            if options.inverted ~= nil then data.Inverted = options.inverted end
            if options.favoritesOnly ~= nil then data.OnlyUseFavorites = options.favoritesOnly end
        end
        return data
    end

    if not _selectiveUnlockApplied then
        _selectiveUnlockApplied = true

        _loadSelectiveConfig()

        local _origOwnsCosmetic = _CosmeticLibrary.OwnsCosmetic
        _CosmeticLibrary.OwnsCosmetic = function(self, inventory, name, weapon)
            if _selectiveUnlockedItems[name] then return true end
            return _origOwnsCosmetic(self, inventory, name, weapon)
        end

        if _CosmeticLibrary.OwnsCosmeticNormally then
            local _origNormally = _CosmeticLibrary.OwnsCosmeticNormally
            _CosmeticLibrary.OwnsCosmeticNormally = function(self, inventory, name, weapon)
                if _selectiveUnlockedItems[name] then return true end
                if type(_origNormally) == "function" then return _origNormally(self, inventory, name, weapon) end
                return false
            end
        end

        if _CosmeticLibrary.OwnsCosmeticUniversally then
            local _origUniversally = _CosmeticLibrary.OwnsCosmeticUniversally
            _CosmeticLibrary.OwnsCosmeticUniversally = function(self, inventory, name)
                if _selectiveUnlockedItems[name] then return true end
                if type(_origUniversally) == "function" then return _origUniversally(self, inventory, name) end
                return false
            end
        end

        if _CosmeticLibrary.OwnsCosmeticForWeapon then
            local _origForWeapon = _CosmeticLibrary.OwnsCosmeticForWeapon
            _CosmeticLibrary.OwnsCosmeticForWeapon = function(self, inventory, name, weapon)
                if _selectiveUnlockedItems[name] then return true end
                if type(_origForWeapon) == "function" then return _origForWeapon(self, inventory, name, weapon) end
                return false
            end
        end

        local _origGet = _DataController.Get
        _DataController.Get = function(self, key)
            local data = _origGet(self, key)
            if key == "CosmeticInventory" then
                local proxy = {}
                if data then for k, v in pairs(data) do proxy[k] = v end end
                return setmetatable(proxy, {
                    __index = function(_, k)
                        if _selectiveUnlockedItems[k] then return true end
                        return nil
                    end
                })
            end
            if key == "FavoritedCosmetics" then
                local result = data and table.clone(data) or {}
                for weapon, favs in pairs(_selectiveFavorites) do
                    result[weapon] = result[weapon] or {}
                    for name, isFav in pairs(favs) do result[weapon][name] = isFav end
                end
                return result
            end
            return data
        end

        local _origGetWeaponData = _DataController.GetWeaponData
        _DataController.GetWeaponData = function(self, weaponName)
            local data = _origGetWeaponData(self, weaponName)
            if not data then return nil end
            local merged = {}
            for key, value in pairs(data) do merged[key] = value end
            merged.Name = weaponName
            if _selectiveEquipped[weaponName] then
                for cosmeticType, cosmeticData in pairs(_selectiveEquipped[weaponName]) do
                    merged[cosmeticType] = cosmeticData
                end
            end
            return merged
        end

        local _FighterController
        pcall(function() _FighterController = require(_controllers:WaitForChild("FighterController", 10)) end)

        if hookmetamethod then
            local remotes = ReplicatedStorage:FindFirstChild("Remotes")
            local dataRemotes = remotes and remotes:FindFirstChild("Data")
            local equipRemote = dataRemotes and dataRemotes:FindFirstChild("EquipCosmetic")
            local favoriteRemote = dataRemotes and dataRemotes:FindFirstChild("FavoriteCosmetic")
            local replicationRemotes = remotes and remotes:FindFirstChild("Replication")
            local fighterRemotes = replicationRemotes and replicationRemotes:FindFirstChild("Fighter")
            local useItemRemote = fighterRemotes and fighterRemotes:FindFirstChild("UseItem")

            if equipRemote then
                local oldNamecall
                oldNamecall = hookmetamethod(game, "__namecall", function(self, ...)
                    if getnamecallmethod() ~= "FireServer" then return oldNamecall(self, ...) end
                    local args = {...}

                    if useItemRemote and self == useItemRemote then
                        local objectID = args[1]
                        if _FighterController then
                            pcall(function()
                                local fighter = _FighterController:GetFighter(_player)
                                if fighter and fighter.Items then
                                    for _, item in pairs(fighter.Items) do
                                        if item:Get("ObjectID") == objectID then
                                            _selectiveLastUsedWeapon = item.Name
                                            break
                                        end
                                    end
                                end
                            end)
                        end
                    end

                    if self == equipRemote then
                        local weaponName, cosmeticType, cosmeticName, options = args[1], args[2], args[3], args[4] or {}

                        if cosmeticName and cosmeticName ~= "None" and cosmeticName ~= "" then
                            if not _selectiveUnlockedItems[cosmeticName] then
                                return oldNamecall(self, ...)
                            end
                            local inventory = _origGet(_DataController, "CosmeticInventory")
                            if inventory and type(inventory) == "table" and rawget(inventory, cosmeticName) then
                                return oldNamecall(self, ...)
                            end
                        end

                        _selectiveEquipped[weaponName] = _selectiveEquipped[weaponName] or {}

                        if not cosmeticName or cosmeticName == "None" or cosmeticName == "" then
                            _selectiveEquipped[weaponName][cosmeticType] = nil
                            if not next(_selectiveEquipped[weaponName]) then _selectiveEquipped[weaponName] = nil end
                        else
                            local cloned = _selCloneCosmetic(cosmeticName, cosmeticType, {inverted = options.IsInverted, favoritesOnly = options.OnlyUseFavorites})
                            if cloned then _selectiveEquipped[weaponName][cosmeticType] = cloned end
                        end

                        task.defer(function()
                            pcall(function() _DataController.CurrentData:Replicate("WeaponInventory") end)
                            task.wait(0.2)
                            _saveSelectiveConfig()
                        end)
                        return
                    end

                    if self == favoriteRemote then
                        local cosmeticName = args[2]
                        if cosmeticName and _selectiveUnlockedItems[cosmeticName] then
                            _selectiveFavorites[args[1]] = _selectiveFavorites[args[1]] or {}
                            _selectiveFavorites[args[1]][cosmeticName] = args[3] or nil
                            _saveSelectiveConfig()
                            task.spawn(function() pcall(function() _DataController.CurrentData:Replicate("FavoritedCosmetics") end) end)
                            return
                        end
                    end

                    return oldNamecall(self, ...)
                end)
            end
        end

        local _selConstructingWeapon = nil

        local _ClientItem
        pcall(function() _ClientItem = require(_player.PlayerScripts.Modules.ClientReplicatedClasses.ClientFighter.ClientItem) end)
        if _ClientItem and _ClientItem._CreateViewModel then
            local _originalCreateViewModel = _ClientItem._CreateViewModel
            _ClientItem._CreateViewModel = function(self, viewmodelRef)
                local weaponName = self.Name
                local weaponPlayer = self.ClientFighter and self.ClientFighter.Player
                _selConstructingWeapon = (weaponPlayer == _player) and weaponName or nil

                if weaponPlayer == _player and _selectiveEquipped[weaponName] and _selectiveEquipped[weaponName].Skin and viewmodelRef then
                    pcall(function()
                        local dataKey, skinKey, nameKey = self:ToEnum("Data"), self:ToEnum("Skin"), self:ToEnum("Name")
                        if viewmodelRef[dataKey] then
                            viewmodelRef[dataKey][skinKey] = _selectiveEquipped[weaponName].Skin
                            viewmodelRef[dataKey][nameKey] = _selectiveEquipped[weaponName].Skin.Name
                        elseif viewmodelRef.Data then
                            viewmodelRef.Data.Skin = _selectiveEquipped[weaponName].Skin
                            viewmodelRef.Data.Name = _selectiveEquipped[weaponName].Skin.Name
                        end
                    end)
                end

                local result = _originalCreateViewModel(self, viewmodelRef)
                _selConstructingWeapon = nil
                return result
            end
        end

        local _viewModelModule = _player.PlayerScripts.Modules.ClientReplicatedClasses.ClientFighter.ClientItem:FindFirstChild("ClientViewModel")
        if _viewModelModule then
            local _ClientViewModel = require(_viewModelModule)
            if _ClientViewModel.GetWrap then
                local _originalGetWrap = _ClientViewModel.GetWrap
                _ClientViewModel.GetWrap = function(self)
                    local weaponName = self.ClientItem and self.ClientItem.Name
                    local weaponPlayer = self.ClientItem and self.ClientItem.ClientFighter and self.ClientItem.ClientFighter.Player
                    if weaponName and weaponPlayer == _player and _selectiveEquipped[weaponName] and _selectiveEquipped[weaponName].Wrap then
                        return _selectiveEquipped[weaponName].Wrap
                    end
                    return _originalGetWrap(self)
                end
            end
            local _originalNew = _ClientViewModel.new
            _ClientViewModel.new = function(replicatedData, clientItem)
                local weaponPlayer = clientItem.ClientFighter and clientItem.ClientFighter.Player
                local weaponName = _selConstructingWeapon or clientItem.Name
                if weaponPlayer == _player and _selectiveEquipped[weaponName] then
                    pcall(function()
                        local ReplicatedClass = require(ReplicatedStorage.Modules.ReplicatedClass)
                        local dataKey = ReplicatedClass:ToEnum("Data")
                        replicatedData[dataKey] = replicatedData[dataKey] or {}
                        local cosmetics = _selectiveEquipped[weaponName]
                        if cosmetics.Skin then replicatedData[dataKey][ReplicatedClass:ToEnum("Skin")] = cosmetics.Skin end
                        if cosmetics.Wrap then replicatedData[dataKey][ReplicatedClass:ToEnum("Wrap")] = cosmetics.Wrap end
                        if cosmetics.Charm then replicatedData[dataKey][ReplicatedClass:ToEnum("Charm")] = cosmetics.Charm end
                    end)
                end
                local result = _originalNew(replicatedData, clientItem)
                if weaponPlayer == _player and _selectiveEquipped[weaponName] and _selectiveEquipped[weaponName].Wrap and result._UpdateWrap then
                    result:_UpdateWrap()
                    task.delay(0.1, function() if not result._destroyed then result:_UpdateWrap() end end)
                end
                return result
            end
        end

        if _ItemLibrary and _ItemLibrary.GetViewModelImageFromWeaponData then
            local _originalGetViewModelImage = _ItemLibrary.GetViewModelImageFromWeaponData
            _ItemLibrary.GetViewModelImageFromWeaponData = function(self, weaponData, highRes)
                if not weaponData then return _originalGetViewModelImage(self, weaponData, highRes) end
                local weaponName = weaponData.Name
                if _selectiveEquipped[weaponName] and _selectiveEquipped[weaponName].Skin then
                    local skinInfo = self.ViewModels[_selectiveEquipped[weaponName].Skin.Name]
                    if skinInfo then return skinInfo[highRes and "ImageHighResolution" or "Image"] or skinInfo.Image end
                end
                return _originalGetViewModelImage(self, weaponData, highRes)
            end
        end

        local _ClientEntity
        pcall(function() _ClientEntity = require(_player.PlayerScripts.Modules.ClientReplicatedClasses.ClientEntity) end)
        if _ClientEntity and _ClientEntity.ReplicateFromServer then
            local _originalReplicateFromServer = _ClientEntity.ReplicateFromServer
            _ClientEntity.ReplicateFromServer = function(self, action, ...)
                if action == "FinisherEffect" then
                    local args = {...}
                    local killerName = args[3]
                    local decodedKiller = killerName
                    if type(killerName) == "userdata" and _EnumLibrary and _EnumLibrary.FromEnum then
                        local ok, decoded = pcall(_EnumLibrary.FromEnum, _EnumLibrary, killerName)
                        if ok and decoded then decodedKiller = decoded end
                    end
                    local isOurKill = tostring(decodedKiller) == _player.Name or tostring(decodedKiller):lower() == _player.Name:lower()
                    if isOurKill and _selectiveLastUsedWeapon and _selectiveEquipped[_selectiveLastUsedWeapon] and _selectiveEquipped[_selectiveLastUsedWeapon].Finisher then
                        local finisherData = _selectiveEquipped[_selectiveLastUsedWeapon].Finisher
                        local finisherEnum = finisherData.Enum
                        if not finisherEnum and _EnumLibrary then
                            local ok2, result = pcall(_EnumLibrary.ToEnum, _EnumLibrary, finisherData.Name)
                            if ok2 and result then finisherEnum = result end
                        end
                        if finisherEnum then
                            args[1] = finisherEnum
                            return _originalReplicateFromServer(self, action, unpack(args))
                        end
                    end
                end
                return _originalReplicateFromServer(self, action, ...)
            end
        end
    end

    _saveSelectiveConfig()
    pcall(function() _DataController.CurrentData:Replicate("CosmeticInventory") end)
    pcall(function() _DataController.CurrentData:Replicate("WeaponInventory") end)

    return unlockSet
end

RunService.Heartbeat:Connect(injectActiveWeapon)

PlayerData:GetDataChangedSignal("WeaponInventory"):Connect(function()
    for weaponName, _ in pairs(cosmeticConfig) do
        if weaponName ~= "_global" then
            if findWeaponEntry(weaponName) then
                injectWeaponData(weaponName)
            end
        end
    end
end)

for weaponName, _ in pairs(cosmeticConfig) do
    if weaponName ~= "_global" then
        if findWeaponEntry(weaponName) then
            injectWeaponData(weaponName)
        end
    end
end

local function getEquippedSkin(weapon)
    if cosmeticConfig[weapon] and cosmeticConfig[weapon].Skin then
        return cosmeticConfig[weapon].Skin.Name or "Default"
    end
    local weaponInventory = PlayerData:Get("WeaponInventory")
    if weaponInventory then
        for _, weaponEntry in pairs(weaponInventory) do
            if weaponEntry.Name == weapon then
                if weaponEntry.Skin and type(weaponEntry.Skin) == "table" and weaponEntry.Skin.Name then
                    return weaponEntry.Skin.Name
                elseif weaponEntry.Skin and type(weaponEntry.Skin) == "string" and weaponEntry.Skin ~= "" then
                    return weaponEntry.Skin
                end
                break
            end
        end
    end
    return "Default"
end

local function getEquippedWrap(weapon)
    if cosmeticConfig[weapon] and cosmeticConfig[weapon].Wrap then
        return cosmeticConfig[weapon].Wrap.Name or "None"
    end
    local weaponInventory = PlayerData:Get("WeaponInventory")
    if weaponInventory then
        for _, weaponEntry in pairs(weaponInventory) do
            if weaponEntry.Name == weapon then
                if weaponEntry.Wrap and type(weaponEntry.Wrap) == "table" and weaponEntry.Wrap.Name then
                    return weaponEntry.Wrap.Name
                elseif weaponEntry.Wrap and type(weaponEntry.Wrap) == "string" and weaponEntry.Wrap ~= "" then
                    return weaponEntry.Wrap
                end
                break
            end
        end
    end
    return "None"
end

local function getEquippedCharm(weapon)
    if cosmeticConfig[weapon] and cosmeticConfig[weapon].Charm then
        return cosmeticConfig[weapon].Charm.Name or "None"
    end
    local weaponInventory = PlayerData:Get("WeaponInventory")
    if weaponInventory then
        for _, weaponEntry in pairs(weaponInventory) do
            if weaponEntry.Name == weapon then
                if weaponEntry.Charm and type(weaponEntry.Charm) == "table" and weaponEntry.Charm.Name then
                    return weaponEntry.Charm.Name
                elseif weaponEntry.Charm and type(weaponEntry.Charm) == "string" and weaponEntry.Charm ~= "" then
                    return weaponEntry.Charm
                end
                break
            end
        end
    end
    return "None"
end

local function getEquippedFinisher(weapon)
    if cosmeticConfig[weapon] and cosmeticConfig[weapon].Finisher then
        return cosmeticConfig[weapon].Finisher.Name or "None"
    end
    local weaponInventory = PlayerData:Get("WeaponInventory")
    if weaponInventory then
        for _, weaponEntry in pairs(weaponInventory) do
            if weaponEntry.Name == weapon then
                if weaponEntry.Finisher and type(weaponEntry.Finisher) == "table" and weaponEntry.Finisher.Name then
                    return weaponEntry.Finisher.Name
                elseif weaponEntry.Finisher and type(weaponEntry.Finisher) == "string" and weaponEntry.Finisher ~= "" then
                    return weaponEntry.Finisher
                end
                break
            end
        end
    end
    return "None"
end

local sortedWeapons = {}
for weapon in pairs(SkinLists) do
    table.insert(sortedWeapons, weapon)
end
table.sort(sortedWeapons)

local repo = "https://raw.githubusercontent.com/deividcomsono/Obsidian/main/"
local Library = loadstring(game:HttpGet(repo .. "Library.lua"))()
local ThemeManager = loadstring(game:HttpGet(repo .. "addons/ThemeManager.lua"))()
local SaveManager = loadstring(game:HttpGet(repo .. "addons/SaveManager.lua"))()

local Options = Library.Options
local Toggles = Library.Toggles

Library.ShowToggleFrameInKeybinds = true

local Window = Library:CreateWindow({
    Title = "Yorijin",
    Footer = "Cosmetic Changer",
    Center = true,
    AutoShow = not _G.GlobalData.SilentLoad,
    ShowCustomCursor = true,
    NotifySide = "Right",
})

local Tabs = {
    Weapons = Window:AddTab("Weapons", "swords"),
    Unlock = Window:AddTab("Unlock", "unlock"),
    Spoofer = Window:AddTab("Spoofer", "eye"),
    Settings = Window:AddTab("Settings", "settings"),
    ["UI Settings"] = Window:AddTab("UI Settings", "palette"),
}

local WeaponSelectGroup = Tabs.Weapons:AddLeftGroupbox("Weapon Selection")

WeaponSelectGroup:AddDropdown("WeaponSelect", {
    Text = "Select Weapon",
    Values = sortedWeapons,
    Default = nil,
    Multi = false,
})

local PreviewGroup = Tabs.Weapons:AddLeftGroupbox("Preview")

local previewImage = nil
local previewLabel = nil
local previewSubLabel = nil

do
    local container = PreviewGroup.Container

    local previewHolder = Instance.new("Frame")
    previewHolder.Name = "PreviewHolder"
    previewHolder.Size = UDim2.new(1, 0, 0, 160)
    previewHolder.BackgroundColor3 = Color3.fromRGB(20, 20, 20)
    previewHolder.BorderSizePixel = 0
    previewHolder.LayoutOrder = 1
    previewHolder.Parent = container
    Instance.new("UICorner", previewHolder).CornerRadius = UDim.new(0, 8)

    previewImage = Instance.new("ImageLabel")
    previewImage.Name = "PreviewImage"
    previewImage.Size = UDim2.new(1, -16, 1, -50)
    previewImage.Position = UDim2.new(0, 8, 0, 8)
    previewImage.BackgroundTransparency = 1
    previewImage.Image = ""
    previewImage.ScaleType = Enum.ScaleType.Fit
    previewImage.Parent = previewHolder

    previewLabel = Instance.new("TextLabel")
    previewLabel.Name = "PreviewName"
    previewLabel.Size = UDim2.new(1, -16, 0, 20)
    previewLabel.Position = UDim2.new(0, 8, 1, -38)
    previewLabel.BackgroundTransparency = 1
    previewLabel.Text = "No selection"
    previewLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
    previewLabel.Font = Enum.Font.GothamBold
    previewLabel.TextSize = 12
    previewLabel.TextXAlignment = Enum.TextXAlignment.Left
    previewLabel.TextTruncate = Enum.TextTruncate.AtEnd
    previewLabel.Parent = previewHolder

    previewSubLabel = Instance.new("TextLabel")
    previewSubLabel.Name = "PreviewSub"
    previewSubLabel.Size = UDim2.new(1, -16, 0, 16)
    previewSubLabel.Position = UDim2.new(0, 8, 1, -18)
    previewSubLabel.BackgroundTransparency = 1
    previewSubLabel.Text = ""
    previewSubLabel.TextColor3 = Color3.fromRGB(120, 120, 120)
    previewSubLabel.Font = Enum.Font.GothamMedium
    previewSubLabel.TextSize = 10
    previewSubLabel.TextXAlignment = Enum.TextXAlignment.Left
    previewSubLabel.TextTruncate = Enum.TextTruncate.AtEnd
    previewSubLabel.Parent = previewHolder
end

local function updatePreview(itemName, itemType)
    if not itemName or itemName == "None" or itemName == "Default" then
        previewImage.Image = ""
        previewLabel.Text = itemName or "No selection"
        previewSubLabel.Text = itemType or ""
        return
    end
    local img = getSkinImage(itemName)
    previewImage.Image = img
    previewLabel.Text = itemName
    local rarity = ""
    pcall(function()
        local cosData = CosmeticLibrary.Cosmetics[itemName]
        if cosData and cosData.Rarity then
            rarity = " • " .. cosData.Rarity
        end
    end)
    previewSubLabel.Text = (itemType or "") .. rarity
end

local SkinGroup = Tabs.Weapons:AddRightGroupbox("Skin")
local WrapGroup = Tabs.Weapons:AddRightGroupbox("Wrap")
local CharmGroup = Tabs.Weapons:AddRightGroupbox("Charm")
local FinisherGroup = Tabs.Weapons:AddRightGroupbox("Finisher")

SkinGroup:AddDropdown("SkinSelect", {
    Text = "Select Skin",
    Values = {"Default"},
    Default = "Default",
    Multi = false,
})

WrapGroup:AddDropdown("WrapSelect", {
    Text = "Select Wrap",
    Values = WrapList,
    Default = "None",
    Multi = false,
})

CharmGroup:AddDropdown("CharmSelect", {
    Text = "Select Charm",
    Values = CharmList,
    Default = "None",
    Multi = false,
})

FinisherGroup:AddDropdown("FinisherSelect", {
    Text = "Select Finisher",
    Values = FinisherList,
    Default = "None",
    Multi = false,
})

local selectedWeapon = nil
local ignoreCallbacks = false
local lastPreviewType = "Weapon"

local function refreshDropdownsForWeapon(weapon)
    if not weapon then return end
    selectedWeapon = weapon
    ignoreCallbacks = true

    local skins = SkinLists[weapon] or {"Default"}
    Options.SkinSelect:SetValues(skins)
    Options.SkinSelect:SetValue(getEquippedSkin(weapon))
    Options.WrapSelect:SetValue(getEquippedWrap(weapon))
    Options.CharmSelect:SetValue(getEquippedCharm(weapon))
    Options.FinisherSelect:SetValue(getEquippedFinisher(weapon))

    updatePreview(weapon, "Weapon")
    lastPreviewType = "Weapon"

    ignoreCallbacks = false
end

Options.WeaponSelect:OnChanged(function()
    local val = Options.WeaponSelect.Value
    if val and SkinLists[val] then
        refreshDropdownsForWeapon(val)
    end
end)

Options.SkinSelect:OnChanged(function()
    if ignoreCallbacks then return end
    if not selectedWeapon then return end
    local val = Options.SkinSelect.Value
    if val then
        equipCosmetic(selectedWeapon, "Skin", val)
        updatePreview(val, "Skin")
        lastPreviewType = "Skin"
    end
end)

Options.WrapSelect:OnChanged(function()
    if ignoreCallbacks then return end
    if not selectedWeapon then return end
    local val = Options.WrapSelect.Value
    if val then
        equipCosmetic(selectedWeapon, "Wrap", val)
        updatePreview(val, "Wrap")
        lastPreviewType = "Wrap"
    end
end)

Options.CharmSelect:OnChanged(function()
    if ignoreCallbacks then return end
    if not selectedWeapon then return end
    local val = Options.CharmSelect.Value
    if val then
        equipCosmetic(selectedWeapon, "Charm", val)
        updatePreview(val, "Charm")
        lastPreviewType = "Charm"
    end
end)

Options.FinisherSelect:OnChanged(function()
    if ignoreCallbacks then return end
    if not selectedWeapon then return end
    local val = Options.FinisherSelect.Value
    if val then
        equipCosmetic(selectedWeapon, "Finisher", val)
        updatePreview(val, "Finisher")
        lastPreviewType = "Finisher"
    end
end)

local WrapAllGroup = Tabs.Weapons:AddLeftGroupbox("Batch Actions")

WrapAllGroup:AddButton({
    Text = "Apply Current Wrap to All Weapons",
    Func = function()
        if not selectedWeapon then
            Library:Notify("Select a weapon first", 2)
            return
        end
        local currentWrap = getEquippedWrap(selectedWeapon)
        if currentWrap == "None" then
            Library:Notify("Select a wrap on the current weapon first", 2)
            return
        end
        applyWrapToAll(currentWrap)
        Library:Notify("Wrap '" .. currentWrap .. "' applied to all weapons!", 3)
    end,
})

WrapAllGroup:AddButton({
    Text = "Remove All Wraps",
    Func = function()
        applyWrapToAll("None")
        if selectedWeapon then
            ignoreCallbacks = true
            Options.WrapSelect:SetValue("None")
            ignoreCallbacks = false
        end
        Library:Notify("All wraps removed!", 2)
    end,
})

WrapAllGroup:AddButton({
    Text = "Reset Current Weapon",
    Func = function()
        if not selectedWeapon then
            Library:Notify("Select a weapon first", 2)
            return
        end
        cosmeticConfig[selectedWeapon] = nil
        if findWeaponEntry(selectedWeapon) then
            local weaponInventory = PlayerData:Get("WeaponInventory")
            if weaponInventory then
                for _, weaponEntry in pairs(weaponInventory) do
                    if weaponEntry.Name == selectedWeapon then
                        weaponEntry.Skin = nil
                        weaponEntry.Wrap = nil
                        weaponEntry.Charm = nil
                        weaponEntry.Finisher = nil
                        break
                    end
                end
            end
        end
        injectActiveWeapon()
        saveConfig()
        pcall(function() PlayerData:Replicate("WeaponInventory") end)
        refreshDropdownsForWeapon(selectedWeapon)
        Library:Notify(selectedWeapon .. " reset to default!", 2)
    end,
})

WrapAllGroup:AddButton({
    Text = "Reset All Weapons",
    Func = function()
        local weaponInventory = PlayerData:Get("WeaponInventory")
        for weaponName, _ in pairs(cosmeticConfig) do
            if weaponName ~= "_global" and weaponInventory then
                for _, weaponEntry in pairs(weaponInventory) do
                    if weaponEntry.Name == weaponName then
                        weaponEntry.Skin = nil
                        weaponEntry.Wrap = nil
                        weaponEntry.Charm = nil
                        weaponEntry.Finisher = nil
                        break
                    end
                end
            end
        end
        local globalBackup = cosmeticConfig._global
        cosmeticConfig = {}
        if globalBackup then
            cosmeticConfig._global = globalBackup
        end
        injectActiveWeapon()
        saveConfig()
        pcall(function() PlayerData:Replicate("WeaponInventory") end)
        if selectedWeapon then
            refreshDropdownsForWeapon(selectedWeapon)
        end
        Library:Notify("All weapons reset to default!", 2)
    end,
})

local UnlockAllGroup = Tabs.Unlock:AddLeftGroupbox("Unlock All")

UnlockAllGroup:AddButton({
    Text = "Unlock All Cosmetics",
    Func = function()
        task.spawn(function()
            unlockAllCosmetics()
            Library:Notify("All cosmetics unlocked! You can now equip anything from the in-game menu.", 4)
        end)
    end,
})

UnlockAllGroup:AddLabel("Unlocks every skin, wrap, charm & finisher at once.")

local UnlockSkinsGroup = Tabs.Unlock:AddRightGroupbox("Unlock Specific Skins")

UnlockSkinsGroup:AddDropdown("SelectiveUnlockSkins", {
    Text = "Select Skins",
    Values = AllSkinNames,
    Default = {},
    Multi = true,
})

UnlockSkinsGroup:AddButton({
    Text = "Unlock Selected Skins",
    Func = function()
        local selected = Options.SelectiveUnlockSkins.Value
        local list = {}
        for name, enabled in pairs(selected) do
            if enabled then table.insert(list, name) end
        end
        if #list == 0 then
            Library:Notify("No skins selected", 2)
            return
        end
        unlockSelectiveCosmetics(list, nil, nil, nil)
        Library:Notify("Unlocked " .. #list .. " skin(s)!", 3)
    end,
})

local UnlockWrapsGroup = Tabs.Unlock:AddRightGroupbox("Unlock Specific Wraps")

local wrapUnlockValues = {}
for _, w in ipairs(WrapList) do
    if w ~= "None" then table.insert(wrapUnlockValues, w) end
end

UnlockWrapsGroup:AddDropdown("SelectiveUnlockWraps", {
    Text = "Select Wraps",
    Values = wrapUnlockValues,
    Default = {},
    Multi = true,
})

UnlockWrapsGroup:AddButton({
    Text = "Unlock Selected Wraps",
    Func = function()
        local selected = Options.SelectiveUnlockWraps.Value
        local list = {}
        for name, enabled in pairs(selected) do
            if enabled then table.insert(list, name) end
        end
        if #list == 0 then
            Library:Notify("No wraps selected", 2)
            return
        end
        unlockSelectiveCosmetics(nil, list, nil, nil)
        Library:Notify("Unlocked " .. #list .. " wrap(s)!", 3)
    end,
})

local UnlockCharmsGroup = Tabs.Unlock:AddLeftGroupbox("Unlock Specific Charms")

local charmUnlockValues = {}
for _, c in ipairs(CharmList) do
    if c ~= "None" then table.insert(charmUnlockValues, c) end
end

UnlockCharmsGroup:AddDropdown("SelectiveUnlockCharms", {
    Text = "Select Charms",
    Values = charmUnlockValues,
    Default = {},
    Multi = true,
})

UnlockCharmsGroup:AddButton({
    Text = "Unlock Selected Charms",
    Func = function()
        local selected = Options.SelectiveUnlockCharms.Value
        local list = {}
        for name, enabled in pairs(selected) do
            if enabled then table.insert(list, name) end
        end
        if #list == 0 then
            Library:Notify("No charms selected", 2)
            return
        end
        unlockSelectiveCosmetics(nil, nil, list, nil)
        Library:Notify("Unlocked " .. #list .. " charm(s)!", 3)
    end,
})

local UnlockFinishersGroup = Tabs.Unlock:AddLeftGroupbox("Unlock Specific Finishers")

local finisherUnlockValues = {}
for _, f in ipairs(FinisherList) do
    if f ~= "None" and f ~= "Ragdoll" then table.insert(finisherUnlockValues, f) end
end

UnlockFinishersGroup:AddDropdown("SelectiveUnlockFinishers", {
    Text = "Select Finishers",
    Values = finisherUnlockValues,
    Default = {},
    Multi = true,
})

UnlockFinishersGroup:AddButton({
    Text = "Unlock Selected Finishers",
    Func = function()
        local selected = Options.SelectiveUnlockFinishers.Value
        local list = {}
        for name, enabled in pairs(selected) do
            if enabled then table.insert(list, name) end
        end
        if #list == 0 then
            Library:Notify("No finishers selected", 2)
            return
        end
        unlockSelectiveCosmetics(nil, nil, nil, list)
        Library:Notify("Unlocked " .. #list .. " finisher(s)!", 3)
    end,
})

do
    local cloneref = cloneref or function(o) return o end
    local clonefunction = clonefunction or clonefunc or function(f) return f end
    local hookfunction = hookfunction or replaceclosure or detour_function
    local hookmetamethod = hookmetamethod
    local newcclosure = newcclosure
    local checkcaller = checkcaller
    local getconnections = getconnections
    local getnamecallmethod = getnamecallmethod
    local iscclosure = iscclosure
    local getinfo = getinfo or debug.getinfo

    local Ps = cloneref(game:GetService("Players"))
    local Sg = cloneref(game:GetService("StarterGui"))
    local Cg = cloneref(game:GetService("CoreGui"))
    local Tcs = cloneref(game:GetService("TextChatService"))

    local LP = Ps.LocalPlayer

    local RealDisplayName = LP.DisplayName
    local RealName = LP.Name
    local RealUserId = LP.UserId

    local SPOOFED_DISPLAY_NAME = RealDisplayName
    local SPOOFED_USERNAME = RealName
    local SPOOFED_USERID = nil

    local spooferActive = false

    local oldKick
    oldKick = hookmetamethod(game, "__namecall", newcclosure(function(self, ...)
        local method = getnamecallmethod()
        if method == "Kick" and self == LP then
            return
        end
        if not checkcaller() and spooferActive then
            if self == LP and method == "GetFullName" then
                return "Players." .. SPOOFED_USERNAME
            end
        end
        return oldKick(self, ...)
    end))

    local oldIndex
    oldIndex = hookmetamethod(game, "__index", newcclosure(function(self, key)
        if not checkcaller() and spooferActive then
            if self == LP then
                if key == "DisplayName" then return SPOOFED_DISPLAY_NAME end
                if key == "Name" then return SPOOFED_USERNAME end
                if key == "UserId" and SPOOFED_USERID then return SPOOFED_USERID end
            end
            if typeof(self) == "Instance" and self:IsA("Humanoid") then
                local ch = LP.Character
                if ch and self:IsDescendantOf(ch) and key == "DisplayName" then
                    return SPOOFED_DISPLAY_NAME
                end
            end
        end
        return oldIndex(self, key)
    end))

    local oldNewindex
    oldNewindex = hookmetamethod(game, "__newindex", newcclosure(function(self, key, value)
        if not checkcaller() and spooferActive then
            if typeof(self) == "Instance" and self:IsA("Humanoid") then
                local ch = LP.Character
                if ch and self:IsDescendantOf(ch) and key == "DisplayName" and value ~= SPOOFED_DISPLAY_NAME then
                    return oldNewindex(self, key, SPOOFED_DISPLAY_NAME)
                end
            end
        end
        return oldNewindex(self, key, value)
    end))

    pcall(function()
        for _, conn in getconnections(LP.OnTeleport) do
            if conn.Function then
                pcall(function() conn:Disable() end)
            end
        end
    end)

    pcall(function()
        for _, v in Ps:GetPlayers() do
            if v == LP then
                for _, conn in getconnections(v.Idled) do
                    pcall(function() conn:Disable() end)
                end
            end
        end
    end)

    local realGetName = clonefunction(Ps.GetNameFromUserIdAsync)
    hookfunction(Ps.GetNameFromUserIdAsync, newcclosure(function(self, userId)
        if not checkcaller() and spooferActive and userId == RealUserId then return SPOOFED_USERNAME end
        return realGetName(self, userId)
    end))

    local realGetId = clonefunction(Ps.GetUserIdFromNameAsync)
    hookfunction(Ps.GetUserIdFromNameAsync, newcclosure(function(self, name)
        if not checkcaller() and spooferActive and name == SPOOFED_USERNAME then return SPOOFED_USERID or RealUserId end
        return realGetId(self, name)
    end))

    pcall(function()
        local realGetInfo = clonefunction(Ps.GetPlayerInfoAsync)
        hookfunction(Ps.GetPlayerInfoAsync, newcclosure(function(self, userId)
            local info = realGetInfo(self, userId)
            if not checkcaller() and spooferActive and userId == RealUserId then
                info.Username = SPOOFED_USERNAME
                info.DisplayName = SPOOFED_DISPLAY_NAME
            end
            return info
        end))
    end)

    local function forceHumanoid()
        local ch = LP.Character
        if not ch then return end
        local hum = ch:FindFirstChildOfClass("Humanoid")
        if hum then
            oldNewindex(hum, "DisplayName", SPOOFED_DISPLAY_NAME)
        end
    end

    local bound = setmetatable({}, { __mode = "k" })

    local function shouldReplace(t)
        if t == RealDisplayName then return SPOOFED_DISPLAY_NAME end
        if t == RealName then return SPOOFED_USERNAME end
        if t == "@" .. RealName then return "@" .. SPOOFED_USERNAME end
        return nil
    end

    local function isLibraryGui(obj)
        local p = obj
        while p do
            if p == Library.ScreenGui then return true end
            if p:IsA("ScreenGui") and p.Name == "Obsidian" then return true end
            p = p.Parent
        end
        return false
    end

    local function bindText(obj)
        if bound[obj] then return end
        if isLibraryGui(obj) then return end
        bound[obj] = true
        pcall(function()
            local r = shouldReplace(obj.Text)
            if r then obj.Text = r end
        end)
        pcall(function()
            obj:GetPropertyChangedSignal("Text"):Connect(function()
                if not spooferActive then return end
                local r = shouldReplace(obj.Text)
                if r then obj.Text = r end
            end)
        end)
    end

    local function scanRoot(root)
        for _, obj in root:GetDescendants() do
            pcall(function()
                if (obj:IsA("TextLabel") or obj:IsA("TextButton") or obj:IsA("TextBox")) and not isLibraryGui(obj) then
                    bindText(obj)
                end
            end)
        end
    end

    local function hookRoot(root)
        scanRoot(root)
        root.DescendantAdded:Connect(function(obj)
            task.defer(function()
                if not spooferActive then return end
                pcall(function()
                    if (obj:IsA("TextLabel") or obj:IsA("TextButton") or obj:IsA("TextBox")) and not isLibraryGui(obj) then
                        bindText(obj)
                    end
                end)
            end)
        end)
    end

    local function fullApply()
        if not spooferActive then return end
        forceHumanoid()
        pcall(function() hookRoot(Cg) end)
        pcall(function()
            local pg = LP:FindFirstChild("PlayerGui")
            if pg then hookRoot(pg) end
        end)
    end

    LP.CharacterAdded:Connect(function(character)
        if not spooferActive then return end
        local hum = character:WaitForChild("Humanoid", 10)
        if hum then
            oldNewindex(hum, "DisplayName", SPOOFED_DISPLAY_NAME)
            hum:GetPropertyChangedSignal("DisplayName"):Connect(function()
                if spooferActive and hum.DisplayName ~= SPOOFED_DISPLAY_NAME then
                    oldNewindex(hum, "DisplayName", SPOOFED_DISPLAY_NAME)
                end
            end)
        end
        task.defer(fullApply)
    end)

    pcall(function()
        local ch = LP.Character
        if ch then
            local hum = ch:FindFirstChildOfClass("Humanoid")
            if hum then
                hum:GetPropertyChangedSignal("DisplayName"):Connect(function()
                    if spooferActive and hum.DisplayName ~= SPOOFED_DISPLAY_NAME then
                        oldNewindex(hum, "DisplayName", SPOOFED_DISPLAY_NAME)
                    end
                end)
            end
        end
    end)

    local spoofConfig = {}
    pcall(function()
        if readfile and isfile and isfile(SPOOFER_FILE) then
            spoofConfig = HttpService:JSONDecode(readfile(SPOOFER_FILE))
        end
    end)

    local function saveSpoofConfig()
        pcall(function()
            if writefile then
                writefile(SPOOFER_FILE, HttpService:JSONEncode(spoofConfig))
            end
        end)
    end

    local NameSpooferGroup = Tabs.Spoofer:AddLeftGroupbox("Name Spoofer")

    NameSpooferGroup:AddInput("SpoofDisplayName", {
        Default = RealDisplayName,
        Numeric = false,
        Finished = false,
        Text = "Display Name",
        Placeholder = "Enter display name...",
    })

    NameSpooferGroup:AddInput("SpoofUsername", {
        Default = RealName,
        Numeric = false,
        Finished = false,
        Text = "Username",
        Placeholder = "Enter username...",
    })

    NameSpooferGroup:AddButton({
        Text = "Apply Spoof",
        Func = function()
            local dName = Options.SpoofDisplayName.Value
            local uName = Options.SpoofUsername.Value

            if dName == "" then dName = RealDisplayName end
            if uName == "" then uName = RealName end

            SPOOFED_DISPLAY_NAME = dName
            SPOOFED_USERNAME = uName
            spooferActive = true

            spoofConfig.DisplayName = dName
            spoofConfig.Username = uName
            spoofConfig.Active = true
            saveSpoofConfig()

            bound = setmetatable({}, { __mode = "k" })
            fullApply()

            Library:Notify("Name spoofed to: " .. dName .. " (@" .. uName .. ")", 3)
        end,
    })

    NameSpooferGroup:AddButton({
        Text = "Reset to Real Name",
        Func = function()
            SPOOFED_DISPLAY_NAME = RealDisplayName
            SPOOFED_USERNAME = RealName
            spooferActive = false

            Options.SpoofDisplayName:SetValue(RealDisplayName)
            Options.SpoofUsername:SetValue(RealName)

            spoofConfig.DisplayName = RealDisplayName
            spoofConfig.Username = RealName
            spoofConfig.Active = false
            saveSpoofConfig()

            forceHumanoid()
            bound = setmetatable({}, { __mode = "k" })

            Library:Notify("Name restored to: " .. RealDisplayName .. " (@" .. RealName .. ")", 3)
        end,
    })

    local DeviceSpooferGroup = Tabs.Spoofer:AddLeftGroupbox("Device Spoofer")

    local SetControlsRemote = nil
    pcall(function()
        SetControlsRemote = ReplicatedStorage:WaitForChild("Remotes", 5)
            :WaitForChild("Replication", 5)
            :WaitForChild("Fighter", 5)
            :WaitForChild("SetControls", 5)
    end)

    local deviceOptions = {"MouseKeyboard", "Gamepad", "Touch", "VR"}
    local currentSpoofedDevice = "MouseKeyboard"
    local deviceSpoofEnabled = false

    local function detectCurrentDevice()
        if UserInputService.VREnabled then
            return "VR"
        elseif UserInputService.TouchEnabled and not UserInputService.KeyboardEnabled then
            return "Touch"
        elseif UserInputService.GamepadEnabled and not UserInputService.KeyboardEnabled then
            return "Gamepad"
        else
            return "MouseKeyboard"
        end
    end

    local realDevice = detectCurrentDevice()
    currentSpoofedDevice = spoofConfig.SpoofedDevice or realDevice

    DeviceSpooferGroup:AddDropdown("DeviceSpoofSelect", {
        Text = "Spoof Device",
        Values = deviceOptions,
        Default = currentSpoofedDevice,
        Multi = false,
    })

    local deviceStatusLabel = DeviceSpooferGroup:AddLabel("Device: " .. realDevice)

    local function applyDeviceSpoof()
        if not deviceSpoofEnabled then return end
        if not SetControlsRemote then return end
        pcall(function()
            SetControlsRemote:FireServer(currentSpoofedDevice)
        end)
        deviceStatusLabel:SetText("Device: " .. currentSpoofedDevice .. " (Spoofed)")
    end
        local function removeDeviceSpoof()
        if not SetControlsRemote then return end
        pcall(function()
            SetControlsRemote:FireServer(realDevice)
        end)
        deviceStatusLabel:SetText("Device: " .. realDevice)
    end

    DeviceSpooferGroup:AddToggle("DeviceSpoofToggle", {
        Text = "Enable Device Spoof",
        Default = spoofConfig.DeviceSpoofEnabled or false,
    })

    Toggles.DeviceSpoofToggle:OnChanged(function()
        deviceSpoofEnabled = Toggles.DeviceSpoofToggle.Value
        spoofConfig.DeviceSpoofEnabled = deviceSpoofEnabled
        saveSpoofConfig()

        if deviceSpoofEnabled then
            applyDeviceSpoof()
            Library:Notify("Device spoofed to: " .. currentSpoofedDevice, 2)
        else
            removeDeviceSpoof()
            Library:Notify("Device spoof disabled", 2)
        end
    end)

    Options.DeviceSpoofSelect:OnChanged(function()
        local selected = Options.DeviceSpoofSelect.Value
        if not selected then return end
        currentSpoofedDevice = selected
        spoofConfig.SpoofedDevice = selected
        saveSpoofConfig()

        if deviceSpoofEnabled then
            applyDeviceSpoof()
            Library:Notify("Device spoofed to: " .. selected, 2)
        end
    end)

    if spoofConfig.DeviceSpoofEnabled and SetControlsRemote then
        deviceSpoofEnabled = true
        task.defer(applyDeviceSpoof)
    end

    local SpoofInfoGroup = Tabs.Spoofer:AddRightGroupbox("Info")

    SpoofInfoGroup:AddLabel("More Spoofing Options coming Soon...")

    local StatusGroup = Tabs.Spoofer:AddRightGroupbox("Status")
    local spoofStatusLabel = StatusGroup:AddLabel("Spoofer: Inactive")

    local function updateStatusLabel()
        local deviceStr = deviceSpoofEnabled and (currentSpoofedDevice .. " (Spoofed)") or realDevice
        if spooferActive then
            spoofStatusLabel:SetText("Spoofer: Active\nDisplay: " .. SPOOFED_DISPLAY_NAME .. "\nUsername: " .. SPOOFED_USERNAME .. "\nDevice: " .. deviceStr)
        else
            spoofStatusLabel:SetText("Spoofer: Inactive\nDevice: " .. deviceStr)
        end
    end

    if spoofConfig.Active and spoofConfig.DisplayName and spoofConfig.Username then
        SPOOFED_DISPLAY_NAME = spoofConfig.DisplayName
        SPOOFED_USERNAME = spoofConfig.Username
        spooferActive = true

        pcall(function()
            Options.SpoofDisplayName:SetValue(spoofConfig.DisplayName)
            Options.SpoofUsername:SetValue(spoofConfig.Username)
        end)

        task.defer(function()
            fullApply()
            updateStatusLabel()
        end)
    end

    task.spawn(function()
        while task.wait(1) do
            pcall(updateStatusLabel)
        end
    end)
end

local GeneralGroup = Tabs.Settings:AddLeftGroupbox("General")

GeneralGroup:AddToggle("AutoLoadToggle", {
    Text = "Auto Load on Join",
    Default = _G.GlobalData.AutoLoad,
})

GeneralGroup:AddToggle("SilentLoadToggle", {
    Text = "Silent Load",
    Default = _G.GlobalData.SilentLoad,
})

Toggles.AutoLoadToggle:OnChanged(function()
    _G.GlobalData.AutoLoad = Toggles.AutoLoadToggle.Value
    setupAutoLoad(_G.GlobalData.AutoLoad)
    saveGlobalToConfig()
end)

Toggles.SilentLoadToggle:OnChanged(function()
    _G.GlobalData.SilentLoad = Toggles.SilentLoadToggle.Value
    saveGlobalToConfig()
end)

local LinksGroup = Tabs.Settings:AddLeftGroupbox("Links")

LinksGroup:AddButton({
    Text = "Copy Discord Invite",
    Func = function()
        pcall(function() setclipboard(DISCORD_URL) end)
        Library:Notify("Discord link copied to clipboard!", 2)
        pcall(function()
            if request or http_request or (syn and syn.request) then
                (request or http_request or syn.request)({
                    Url = "http://127.0.0.1:6463/rpc?v=1",
                    Method = "POST",
                    Headers = {["Content-Type"] = "application/json", Origin = "https://discord.com"},
                    Body = HttpService:JSONEncode({cmd = "INVITE_BROWSER", args = {code = "zv8Tdmds"}, nonce = HttpService:GenerateGUID(false)})
                })
            end
        end)
    end,
})

LinksGroup:AddButton({
    Text = "Copy Key Link",
    Func = function()
        pcall(function() setclipboard(KEY_URL) end)
        Library:Notify("Key link copied to clipboard!", 2)
    end,
})

local MenuGroup = Tabs["UI Settings"]:AddLeftGroupbox("Menu")

MenuGroup:AddButton({
    Text = "Unload Script",
    Func = function()
        Library:Unload()
    end,
})

MenuGroup:AddLabel("Menu bind")
MenuGroup:AddKeybind("MenuKeybind", {
    Default = "RightShift",
    NoUI = true,
    Text = "Menu Toggle",
})

Library.ToggleKeybind = Options.MenuKeybind

ThemeManager:SetLibrary(Library)
SaveManager:SetLibrary(Library)

SaveManager:IgnoreThemeSettings()
ThemeManager:SetFolder("Yorijin")
SaveManager:SetFolder("Yorijin/configs")

SaveManager:BuildConfigSection(Tabs["UI Settings"])
ThemeManager:ApplyToTab(Tabs["UI Settings"])

Library:Notify("Yorijin loaded! (" .. #sortedWeapons .. " weapons)", 3)