Autoplayer

()
()
()
()
()
()

 start = ()
 client = :().LocalPlayer;
 set_identity = (() ==   .set_thread_identity)  setidentity  setthreadcontext
 executor = identifyexecutor  ()  

  (r)  client:(r) 



 usedCache = .__urlcache  (.__urlcache) ~= 

.__urlcache = .__urlcache  {}
  (url)
     success, result

     .__urlcache[url] 
        success, result = , .__urlcache[url]
    
        success, result = (.HttpGet, , url)
    

     ( success) 
         (.(, url, (result)))
    

     fn, err = (result)
     ((fn) ~= ) 
         (.(, url, (err)))
    

     results = { (fn) }
     ( results[]) 
         (.(, url, (results[])))
    

    .__urlcache[url] = result
     (results, )




 (set_identity) ~=    () 
 (getconnections) ~=    () 
 (getloadedmodules) ~=    () 
 (getgc) ~=      () 

 getinfo = debug.getinfo  getinfo;
 getupvalue = debug.getupvalue  getupvalue;
 getupvalues = debug.getupvalues  getupvalues;
 setupvalue = debug.setupvalue  setupvalue;

 (setupvalue) ~=    () 
 (getupvalue) ~=    () 
 (getupvalues) ~=    () 


 (getinfo) ~=  
     debug_info = debug.info;
     (debug_info) ~=  
        
         () ~=    () 
        debug_info = ().debug.info
    
    getinfo = (f)
        ((f) == , .(, , (f)))
         results = { debug.(f, ) }
         _, upvalues = (getupvalues, f)
         (upvalues) ~=  
            upvalues = {}
        
         nups = 
         k  , upvalues 
            nups = nups + 
        
        
         {
            source      =  .. results[],
            short_src   = results[],
            what        = results[] ==     ,
            currentline = results[],
            name        = results[],
            func        = results[],
            numparams   = results[],
            is_vararg   = results[], 
            nups        = nups,     
        }
    


 IsMobile = ;
 DevicePlatform = .Platform.None;
(() DevicePlatform = UserInputService:(); );
IsMobile = (DevicePlatform == .Platform.Android  DevicePlatform == .Platform.IOS);
 UIRepo = 
 ScriptRepo = 

 UI = 
 IsMobile 
    UI = (:(UIRepo .. ))()

    UI = (:(UIRepo .. ))()


 metadata = (:(ScriptRepo .. ))()
 httpService = :()

 framework, scrollHandler, network
 counter = 

  
     _, obj  , () 
         (obj) ==   
             (obj, ) 
                framework = obj;
             ((obj, )) ==  
                network = obj;     
            
        

         network  framework   
    

     _, module  , () 
         module.Name ==  
            scrollHandler = module;
            ;
        
     

     ((framework) ==   (scrollHandler) ==   (network) == ) 
        
    

    counter = counter + 
     counter >  
        (.(, (framework), (scrollHandler), (network)))
    
    ()


 runService = :()
 userInputService = :()
 virtualInputManager = :()

 random = Random.()

  =   ().task;
 fastWait, fastSpawn = .wait, .spawn;



 fireSignal, rollChance 
    
    

     (target, signal, ...)
        
        ()
         didFire = 
         _, signal  , (signal) 
             (signal.Function) ==   (signal.Function) 
                 scr = ((signal.Function), )
                 scr == target 
                    didFire = 
                    (signal.Function, ...)
                
            
        
        
        ()
    

    
    

     ()
        
         Options.AutoplayerMode.Value ==  
             (Options.SickBind:())    
             (Options.GoodBind:())    
             (Options.OkayBind:())    
             (Options.BadBind:())    

              
        

         chances = {
            { , Options.SickChance.Value },
            { , Options.GoodChance.Value },
            { , Options.OkChance.Value },
            { , Options.BadChance.Value },
            {  , Options.MissChance.Value },
        }

        .(chances, (a, b)
             a[] > b[]
        )

         sum = ;
         i = , #chances 
            sum += chances[i][]
        

         sum ==  
             chances[random:(, #chances)][]
        

         initialWeight = random:(, sum)
         weight = ;

         i = , #chances 
            weight = weight + chances[i][]

             weight > initialWeight 
                 chances[i][]
            
        

         
    



 chanceValues 
    chanceValues = { 
        Sick = ,
        Good = ,
        Ok = ,
        Bad = ,
    }

     keyCodeMap = {}
     _, enum  , .KeyCode:() 
        keyCodeMap[enum.Value] = enum
    

     ._unload 
        (._unload)
    

     .()
         ._id 
            (runService.UnbindFromRenderStep, runService, ._id)
        

        UI:()

         i = , #.threads 
            .(.threads[i])
        

         i = , #.callbacks 
            .(.callbacks[i])
        
    

    .threads = {}
    .callbacks = {}

    ._id = httpService:()

      (keyCode, state)
         Options.PressMode.Value ==  
            virtualInputManager:(state, keyCode, , )
        
            (scrollHandler, userInputService[state    ], { KeyCode = keyCode, UserInputType = .UserInputType.Keyboard }, )
        
    

     rng = Random.()
    runService:(._id, , ()
        
        
         ( Toggles.Autoplayer)  ( Toggles.Autoplayer.Value)  
             
        

         currentlyPlaying = framework.SongPlayer.CurrentlyPlaying

         (currentlyPlaying) ~=    currentlyPlaying:()  
             
        

         arrows = framework.UI:()
         count = framework.SongPlayer:()
         mode = count .. 

         arrowData = framework.ArrowData[mode].Arrows
         i, arrow  , arrows 
            
             ignoredNoteTypes = { Death = , Mechanic = , Poison =  }

             (arrow.NoteDataConfigs) ==   
                 ignoredNoteTypes[arrow.NoteDataConfigs.Type]  
                    
                
            

             (arrow.Side == framework.UI.CurrentSide)  ( arrow.Marked)  currentlyPlaying.TimePosition >  
                 position = (arrow.Data.Position % count) ..  

                 hitboxOffset =  
                
                     settings = framework.Settings;
                     offset = (settings) ==   settings.HitboxOffset;
                     value = (offset) ==   offset.Value;

                     (value) ==  
                        hitboxOffset = value;
                    

                    hitboxOffset = hitboxOffset / 
                

                 songTime = framework.SongPlayer.CurrentTime
                 playbackSpeed = 
                
                     configs = framework.SongPlayer.CurrentSongConfigs
                     (configs) ==   ((configs, )) ==  
                        playbackSpeed = configs.PlaybackSpeed
                    

                    songTime = songTime / playbackSpeed
                

                 noteTime = .(( - .(arrow.Data.Time - (songTime + hitboxOffset))) * , , )

                 result = ()
                arrow._hitChance = arrow._hitChance  result;

                 hitChance = (Options.AutoplayerMode.Value ==   result  arrow._hitChance)
                 hitChance ~=   noteTime >= chanceValues[arrow._hitChance] 
                    (()
                        arrow.Marked = ;
                         keyCode = keyCodeMap[arrowData[position].Keybinds.Keyboard[]]

                        (keyCode, )

                         arrowLength = arrow.Data.Length  
                         isHeld = arrowLength > 
                                
                         isHeld  arrowLength = arrowLength / playbackSpeed 

                         delayMode = Options.DelayMode.Value

                         minDelay = isHeld  Options.HeldDelayMin  Options.NoteDelayMin;
                         maxDelay = isHeld  Options.HeldDelayMax  Options.NoteDelayMax;
                         noteDelay = isHeld  Options.HeldDelay  Options.ReleaseDelay

                          = delayMode ==   rng:(minDelay.Value, maxDelay.Value)  noteDelay.Value
                        .(arrowLength + ( / ))

                        (keyCode, )
                        arrow.Marked = ;
                    )
                
            
        
    )


 ActivateUnlockables 
    
    

     loadStyle = 
      (...)
        
            
         upvalues = (loadStyle)
         i, upvalue  , upvalues 
             (upvalue) ==   (upvalue, ) 
                (upvalue, , );
                (loadStyle, i, upvalue)
            
        

         (...)
    

      (...)
         gc = ()
         i = , #gc 
             obj = gc[i]
             (obj) ==  
                
                 upvalues = (obj)
                 i, upv  , upvalues 
                     (upv) ==   (upv).name ==  
                        
                          (fn)
                             (fn).source:()
                        

                         (obj)  (upv) 
                            
                            loadStyle = loadStyle  upv
                            (obj, i, loadStyleProxy)

                            .(.callbacks, ()
                                ((setupvalue, obj, i, loadStyle))
                            )
                        
                    
                
            
        
    

     success,  = (applyLoadStyleProxy)
      success 
         (.(, , executor))
    

     ()
         idx = .(framework.SongsWhitelist, client.UserId)
         idx   

        UI:(, )
        .(framework.SongsWhitelist, client.UserId)
    




     (roundManager) ~=  
        .()
        roundManager = network.Server.RoundManager
    

     oldUpdateScore = roundManager.UpdateScore;
     roundManager.(...)
         args = { ... }
         score = args[]

         (score) ==   Options.ScoreModifier 
        
             Options.ScoreModifier.Value ==  
                args[] = 
             Options.ScoreModifier.Value ==  
                args[] = .(score)
            
        

         ((args))
    

    .(.callbacks, ()
        roundManager.UpdateScore = oldUpdateScore
    )




     thread = .(()
         map = :(, )
         buildings = map  map:(, )
         spawners = buildings  buildings:(, )

         spawners ==    
         () ~=     

          
            .()
             Toggles.AutoClaimRings  Toggles.AutoClaimRings.Value 
                 character = client.Character
                 rootPart = character  character:()

                 rootPart ==    

                 i, spawner  , spawners:() 
                     _, ring  , spawner:() 
                         ring.Name ~=    

                         ring = ring:()
                          (ring  ring:())   
                         ring.Transparency ==    

                        (ring, rootPart, )
                        (ring, rootPart, )
                    
                
            
        
    )
    .(.callbacks, ()
        (.cancel, thread)
    )


 SaveManager = {} 
    SaveManager.Ignore = {}
    SaveManager.Parser = {
        Toggle = {
            Save = (idx, object) 
                 {  = , idx = idx, value = object.Value } 
            ,
            Load = (idx, data)
                 Toggles[idx]  
                    Toggles[idx]:(data.value)
                
            ,
        },
        Slider = {
            Save = (idx, object)
                 {  = , idx = idx, value = (object.Value) }
            ,
            Load = (idx, data)
                 Options[idx]  
                    Options[idx]:(data.value)
                
            ,
        },
        Dropdown = {
            Save = (idx, object)
                 {  = , idx = idx, value = object.Value, mutli = object.Multi }
            ,
            Load = (idx, data)
                 Options[idx]  
                    Options[idx]:(data.value)
                
            ,
        },
        ColorPicker = {
            Save = (idx, object)
                 {  = , idx = idx, value = object.Value:() }
            ,
            Load = (idx, data)
                 Options[idx]  
                    Options[idx]:(.(data.value))
                
            ,
        },
        KeyPicker = {
            Save = (idx, object)
                 {  = , idx = idx, mode = object.Mode, key = object.Value }
            ,
            Load = (idx, data)
                 Options[idx]  
                    Options[idx]:({ data.key, data.mode })
                
            ,
        }
    }

     SaveManager:(name)
         fullPath =  .. name .. 

         data = {
            version = ,
            objects = {}
        }

         idx, toggle  , Toggles 
             self.Ignore[idx]   
            .(data.objects, self.Parser[toggle.Type].(idx, toggle))
        

         idx, option  , Options 
              self.Parser[option.Type]   
             self.Ignore[idx]   

            .(data.objects, self.Parser[option.Type].(idx, option))
         

         success, encoded = (httpService.JSONEncode, httpService, data)
          success 
             , 
        

        (fullPath, encoded)
         
    

     SaveManager:(name)
         file =  .. name .. 
          (file)   ,  

         success, decoded = (httpService.JSONDecode, httpService, (file))
          success   ,  
         decoded.version ~=    ,  

         _, option  , decoded.objects 
             self.Parser[option.type] 
                self.Parser[option.type].(option.idx, option)
            
        

         
    

     SaveManager.()
         list = ()

         out = {}
         i = , #list 
             file = list[i]
             file:(-) ==  
                

                 pos = file:(, , )
                 start = pos

                 char = file:(pos, pos)
                 char ~=   char ~=   char ~=  
                    pos = pos - 
                    char = file:(pos, pos)
                

                 char ==   char ==  
                    .(out, file:(pos + , start - ))
                
            
        
        
        Options.ConfigList.Values = out;
        Options.ConfigList:()
        Options.ConfigList:()

         out
    

     SaveManager:(name)
         file =  .. name .. 
          (file)   , .(, name) 

         succ, err = (delfile, file)
          succ 
             , .(, err)
        

         
    

     SaveManager:(list)
         i = , #list  
            .(self.Ignore, list[i])
        
    

     SaveManager.()
         list = ()

         _, file  , list 
             (file)   

             data = (file)
             success, decoded = (httpService.JSONDecode, httpService, data)

             success  (decoded) ==   decoded.version ~=  
                (delfile, file)
            
        
    


 Window = UI:({
    Title = .(, metadata.version, metadata.updated),
    AutoShow = ,
    
    Center = ,
    Size = .(, ),
})

 Tabs = {}
 Groups = {}

Tabs.Main = Window:()
Tabs.Miscellaneous = Window:()

Groups.Autoplayer = Tabs.Main:()
    Groups.Autoplayer:(, { Text =  }):(, { Default = , NoUI = , SyncToggleState =  })
    Groups.Autoplayer:(, {
        Text = , 
        Compact = , 
        Default = , 
        Values = { ,  }, 
        Tooltip = , 
    })

Groups.HitChances = Tabs.Main:()
    Groups.HitChances:(, { 
        Text = , 
        Compact = , 
        Default = , 
        Values = { ,  },
        Tooltip = ,
    })

    Groups.HitChances:(,   { Text = , Min = , Max = , Default = , Suffix = , Rounding = , Compact =  })
    Groups.HitChances:(,   { Text = , Min = , Max = , Default = , Suffix = , Rounding = , Compact =  })
    Groups.HitChances:(,     { Text = ,   Min = , Max = , Default = , Suffix = , Rounding = , Compact =  })
    Groups.HitChances:(,    { Text = ,  Min = , Max = , Default = , Suffix = , Rounding = , Compact =  })
    Groups.HitChances:(,   { Text = , Min = , Max = , Default = , Suffix = , Rounding = , Compact =  })

Groups.HitTiming = Tabs.Main:()
    Groups.HitTiming:(, { 
        Text = , 
        Default = , 
        Values = { ,  },
        Tooltip = , 
    })

    Groups.HitTiming:()
    Groups.HitTiming:(,   { Text = , Min = , Max = , Default = , Rounding = , Compact = , Suffix =  })
    Groups.HitTiming:(,      { Text = , Min = -, Max = , Default = , Rounding = , Compact = , Suffix =  })
        
    Groups.HitTiming:()
    Groups.HitTiming:(,   { Text = , Min = , Max = , Default = ,    Rounding = , Compact = , Suffix =  })
    Groups.HitTiming:(,   { Text = , Min = , Max = , Default = ,   Rounding = , Compact = , Suffix =  })
    
    Groups.HitTiming:(,   { Text = , Min = , Max = , Default = ,   Rounding = , Compact = , Suffix =  })
    Groups.HitTiming:(,   { Text = , Min = , Max = , Default = ,  Rounding = , Compact = , Suffix =  })

Groups.Misc = Tabs.Main:()
    Groups.Misc:(, ActivateUnlockables)
    Groups.Misc:(, { Text =  })

Groups.Keybinds = Tabs.Main:()
    Groups.Keybinds:():(, { Default = , NoUI =  })
    Groups.Keybinds:():(, { Default = , NoUI =  })
    Groups.Keybinds:():(, { Default = , NoUI =  })
    Groups.Keybinds:():(, { Default = , NoUI =  })

Groups.Configs = Tabs.Miscellaneous:()
Groups.Credits = Tabs.Miscellaneous:()
      (label)
        label.TextLabel.RichText = 
    

    (Groups.Credits:())
    (Groups.Credits:())
    Groups.Credits:()
    Groups.Credits:()


Groups.Misc = Tabs.Miscellaneous:()
    Groups.Misc:(metadata.message  , )

    Groups.Misc:()
    Groups.Misc:(, () (._unload) )
    Groups.Misc:(, ()
         (setclipboard, ) 
            UI:(, )
        
    )

    Groups.Misc:():(, { Default = , NoUI =  })

    UI.ToggleKeybind = Options.MenuToggle

 (readfile) ==   (writefile) ==   (makefolder) ==   (isfolder) ==  
    ()
    ()

    Groups.Configs:(, { Text = , Values = {}, AllowNull =  })
    Groups.Configs:(,    { Text =  })

    Groups.Configs:()

    Groups.Configs:(, ()
         name = Options.ConfigName.Value;
         name:(, ) ==  
             UI:(, )
        

         success, err = SaveManager:(name)
          success 
             UI:((err), )
        

        UI:(.(, name), )
        .(SaveManager.Refresh)
    )

    Groups.Configs:(, ()
         name = Options.ConfigList.Value
         success, err = SaveManager:(name)
          success 
             UI:((err), )
        

        UI:(.(, name), )
    ):(, ()
         name = Options.ConfigList.Value
         name:(, ) ==  
             UI:(, )
        

         success, err = SaveManager:(name)
          success 
             UI:((err), )
        

        UI:(.(, name), )

        .(Options.ConfigList.SetValue, Options.ConfigList, )
        .(SaveManager.Refresh)
    )

    Groups.Configs:(, SaveManager.Refresh)

    .(SaveManager.Refresh)
    .(SaveManager.Check)

    Groups.Configs:(, )
    




     latestThemeIndex = 
     i, theme  , themeManager.BuiltInThemes 
         theme[] > latestThemeIndex 
            latestThemeIndex = theme[]
        
    

    latestThemeIndex = latestThemeIndex + 

     linoriaTheme = themeManager.BuiltInThemes.Default[]
     funkyFridayTheme = .(themeManager.BuiltInThemes.Default[])

    funkyFridayTheme.AccentColor = .(, , ):()

    themeManager.BuiltInThemes[] = { latestThemeIndex, linoriaTheme }
    themeManager.BuiltInThemes[] = { , funkyFridayTheme }

    themeManager:(UI)
    themeManager:()
    themeManager:(Tabs.Miscellaneous:())

    SaveManager:({ 
        , , , , , 
        , , , 
    })


UI:(.(, () - start), )