Open Source All Skins, Wraps, Chams, Finishers

.()
 ().RivalsCosmeticsCleanup 
    (().RivalsCosmeticsCleanup)


  :() 
    .Loaded:()


 rs = :()
  = :()
 plr = :().LocalPlayer

  (getter)
     deadline = .() + 
     .() < deadline 
         ok, value = (getter)
         ok  value 
             value
        
        .()
    


 scripts = plr:()
 lib = (()  (rs.Modules.CosmeticLibrary) )
 replicated = (()  (rs.Modules.ReplicatedClass) )
 vmClass = (()  (scripts.Modules.ClientReplicatedClasses.ClientFighter.ClientItem.ClientViewModel) )
 pdc = (()  (scripts.Controllers.PlayerDataController) )
 viewModels = (()  scripts.Assets.ViewModels )
 classes = (()  scripts.Modules.ViewModels )
 equipRemote = (()  rs.Remotes.Data.EquipCosmetic )

  (lib  replicated  vmClass  pdc  viewModels  classes  equipRemote) 
    ()
    


 folder = 
 file = folder .. 
 slots = { Skin = , Wrap = , Charm = , Finisher =  }
 added = {}
 saved = {}
 alive = 
 swaps = {}
 swapping = {}
 moduleCache = {}
 modelCache = {}
 oldGet = replicated.Get
 oldVmGet = (vmClass, )

  (key)
     ok, v = (pdc.CurrentData.Get, pdc.CurrentData, key)
     ok  v  


(()  ()  () )

  ()
    (()
          (folder) 
            (folder)
        
        (file, :(saved))
    )


  (weapon)
     list = ()
      list   
     _, w  (list) 
         w.Name == weapon 
             w
        
    


 inv = ()
 name  (lib.Cosmetics) 
     inv  inv[name] ==  
        inv[name] = 
        added[name] = 
    


(()
     (file) 
        saved = :((file))
    
)

 weapon, picks  (saved) 
     w = (weapon)
     w 
         slot, entry  (picks) 
             slots[slot]  lib.Cosmetics[entry.Name] 
                w[slot] = entry
            
        
    


  (object)
     (object) ~=     
     item = (object, )  object
     fighter = (item) ==   (item, )
     (fighter) ~=     
     owner = (fighter, )
     owner ~=   owner ~= plr


  (...)
     i = , .((, ...), ) 
         (((i, ...))) 
             
        
    
     


  (name)
     cosmetic = lib.Cosmetics[name]
     cosmetic  cosmetic.Type ==   cosmetic.ItemName 
         cosmetic.ItemName
    
     name


  (name)
     cached = moduleCache[name]
     cached ==  
         found = classes:(name, )
        cached = found  found:()  found  
        moduleCache[name] = cached
    
     cached  


  (name)
     cached = modelCache[name]
     cached ==  
        cached = viewModels:(name, ) ~= 
        modelCache[name] = cached
    
     cached


  (weapon, skin)
     defaultModule = (weapon)
     skinModule = skin  (skin.Name)
      (defaultModule  skinModule  (skin.Name))   
     skinModule.Parent ~= defaultModule.Parent  skinModule.Parent ~= defaultModule   
     loaded, skinClass = (, skinModule)
     loaded  (skinClass) ==   (skinClass.new) ==  
         skinClass
    


  (weapon)
     picks = saved[weapon]
     skin = picks  picks.Skin
      skin    
     (weapon, skin)  ( (skin.Name)  (skin.Name)) 
         skin.Name
    
     


  (weapon)
     swaps[weapon]   
     defaultModule = (weapon)
      defaultModule   
     ok, class = (, defaultModule)
      ok  (class) ~=   (class.new) ~=    
     origNew = class.new
    swaps[weapon] = { class = class, origNew = origNew, own = (class, ) ~=  }
    class.new = (...)
         thread = .()
         mine = alive   swapping[thread]   (...)
         picks = mine  saved[weapon]
         skin = picks  picks.Skin
         skinClass = skin  (weapon, skin)
         skinClass 
            swapping[thread] = { weapon = weapon, skin = skin.Name }
             built, object = (skinClass.new, ...)
            swapping[thread] = 
             built 
                 (object) ==  
                    (object, , skin.Name)
                
                 object
            
        
         object = (...)
         mine  (object) ==  
            (object, ,  skinClass  (weapon))
        
         object
    


  (weapon)
      alive   
     wanted = (weapon)
     _, obj  (()) 
         (obj) ==   ((obj, )) ==   (obj, )   (obj, ) 
             item = (obj, )
             (item) ==   (item, ) == obj  (obj.Data.Name) == weapon   (obj)
                 ((obj, )  ) ~= wanted 
                 swap = swaps[weapon]
                 class = swap  swap.class  (obj)
                 serial = (obj, )
                 (class) ==   (class.new) ==   serial 
                    (()
                         setthreadidentity  () 
                         fresh = class.(serial, item)
                         (fresh) ==  
                             (fresh, ) ==  
                                (fresh, , wanted)
                            
                            item.ViewModel = fresh
                            (obj.Destroy, obj)
                        
                    )
                
            
        
    


 weapon, picks  (saved) 
     picks.Skin 
        (weapon)
    


replicated.Get = (self, key)
     alive  slots[key]   (self) 
         data = (self, )
         picks = data  saved[(data.Name)]
         entry = picks  picks[key]
         entry ~=  
             entry
        
    
     (self, key)


vmClass.Get = (self, key)
     alive  key ==    (self) 
         data = (self, )
         data 
             weapon = (data.Name)
             active = swapping[.()]
             active  active.weapon == weapon 
                 active.skin
            
             picks = saved[weapon]
             skin = picks  picks.Skin
             skin   (skin.Name)  (skin.Name)  (data.Name == weapon   (data.Name)) 
                 skin.Name
            
        
    
     (oldVmGet  replicated.Get)(self, key)


  (weapon, slot)
     slot ~=   slot ~=    
     _, obj  (()) 
         (obj) ==   ((obj, )) ==   (obj, )  (obj, )   (obj, )   (obj)  (obj.Data.Name) == weapon 
             entry = saved[weapon]  saved[weapon][slot]
            obj.Data[slot] = entry
             signal = obj._value_changed_events  obj._value_changed_events[slot]
             signal 
                (signal.Fire, signal, entry)
            
             slot ==   obj._UpdateWrap 
                (obj._UpdateWrap, obj)
            
        
    


  (weapon, slot, name, extra)
     w = (weapon)
      w    
     entry
     name 
        entry = { Name = name, Inverted = slot ==   extra  extra.IsInverted   }
    
    w[slot] = entry
    saved[weapon] = saved[weapon]  {}
    saved[weapon][slot] = entry
     slot ==  
        (weapon)
        .(rebuildHeld, weapon)
    
    ()
    (weapon, slot)
     


().RivalsEquipHandler = (self, ...)
      alive  self ~= equipRemote    
     weapon, slot, name, extra = ...
     slots[slot]  (name ==   lib.Cosmetics[name])  (weapon, slot, name, extra)  


  ().RivalsNamecallOriginal 
    ().RivalsNamecallOriginal = (, , ((self, ...)
         handler = ().RivalsEquipHandler
         handler   ()  () ==   (self, ...) 
            
        
         ().(self, ...)
    ))


().RivalsCosmeticsCleanup = ()
    alive = 
    ().RivalsEquipHandler = 
    replicated.Get = oldGet
    vmClass.Get = oldVmGet
     _, swap  (swaps) 
        swap.class.new = swap.own  swap.origNew  
    
     cur = ()
     cur 
         name  (added) 
            cur[name] = 
        
    
    ().RivalsCosmeticsCleanup = 


.(()
     weapon, picks  (saved) 
         picks.Skin 
            (weapon)
        
        (weapon, )
        (weapon, )
    
)