Open Source

 ().AnimeRacingClicker 
    (()
        ().AnimeRacingClicker:()
    )
    ().AnimeRacingClicker = 


 baseUrl = 
 ok, Library = (()
     (:(baseUrl .. ))()
)
  ok   Library 
    


 Players = :()
 ReplicatedStorage = :()
 VirtualUser = :()
 player = Players.LocalPlayer

 Knit = ()._G.Knit
 _ = ,  
     Knit  Knit.Controllers  Knit.Controllers.RaceController 
        
    
    .()
    Knit = ()._G.Knit

  (Knit  Knit.Controllers  Knit.Controllers.RaceController) 
    Library:()
    


().AnimeRacingClicker = Library

 raceController = Knit.Controllers.RaceController
 regionController = Knit.Controllers.RegionController
 autoRunController = Knit.Controllers.AutoRunController
 movementController = Knit.Controllers.RaceMovementController

 clickerService = Knit.()
 movementService = Knit.()
 raceGenerator = Knit.()
 settingsService = Knit.()
 raceService = Knit.()

 regionTable = (ReplicatedStorage.DataBank.RegionTable)

 active = 
 connections = {}
 overlay
 lastJoin = 
 speed = 
 wallsReached = 
 wallsTotal = 
 worldKeys = {}
 autoWorld = 

  (text, time)
    .(()
        (()
            Library:(text, time  )
        )
    )


  (value)
     value >=  
         .(, value)
    
     value >=  
         .(, value / )
    
     value >=  
         .(, value / )
    
     .(, value)


  ()
     .(, raceController.Timer - .())


  ()
     character = player.Character
     character  character:()


  ()
     regionController.playersRegion[player]


  ()
     worlds = {}
     key, data  (regionTable) 
         (data) ==   key ~=   regionController.AllowedRegions[key] 
            .(worlds, {
                key = key,
                money = data.ShurikensMultiplier  ,
                click = data.ClickMultiplier  ,
                name = .(, (data.WorldName), (data.Island), key, (data.ShurikensMultiplier  )),
            })
        
    

    .(worlds, (a, b)
         a.money ~= b.money 
             a.money > b.money
        
         a.click > b.click
    )

    worldKeys = { [autoWorld] = worlds[]  worlds[].key }
     names = { autoWorld }
     _, world  (worlds) 
        worldKeys[world.name] = world.key
        .(names, world.name)
    
     names


  ()
     picked = Library.Options.RaceWorld  Library.Options.RaceWorld.Value
     worldKeys[picked]  ()


  ()
     world = ()
      world  world ==  
        
    
    (()
        movementService.TeleportToRace:(world)
    )


  ()
     success, gain = (()
         clickerService:()
    )
     success  gain  Library.Toggles.ClickEffect.Value 
        (()
            Knit.Controllers.ClickerController:(gain)
        )
    


  (state)
    (()
         state 
            autoRunController:()
        
            autoRunController:()
        
        settingsService:(, state)
    )


 Window = Library:({
    Title = ,
    Footer = ,
    Icon = ,
    NotifySide = ,
    Center = ,
    AutoShow = ,
    ToggleKeybind = .KeyCode.RightControl,
    Folder = ,
})

 Tabs = {
    Main = Window:(, ),
    Clicker = Window:(, ),
    Race = Window:(, ),
}

 Toggles = Library.Toggles
 Options = Library.Options

 stateLabel, worldLabel, speedLabel, wallLabel

  (tab)
     auto = tab:({ Side = , Name = , IconName =  })

    auto:(, {
        Text = ,
        Tooltip = ,
    }):(, {
        Text = ,
        Default = ,
        Mode = ,
        SyncToggleState = ,
    })

    auto:(, {
        Text = ,
        Tooltip = ,
    }):(, {
        Text = ,
        Default = ,
        Mode = ,
        SyncToggleState = ,
    })

    auto:(, {
        Text = ,
        Callback = setAutoRun,
    })

    auto:(, {
        Text = ,
    })

    auto:(, {
        Text = ,
        Default = ,
    })

    auto:({
        Text = ,
        Func = joinRace,
    })

     info = tab:({ Side = , Name = , IconName =  })
    stateLabel = info:()
    worldLabel = info:()
    speedLabel = info:()
    wallLabel = info:()


  (tab)
     box = tab:({ Side = , Name = , IconName =  })

    box:(, {
        Text = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = ,
        Tooltip = ,
    })

    box:(, {
        Text = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = ,
        Suffix = ,
    })

    box:(, {
        Text = ,
    })


  (tab)
     world = tab:({ Side = , Name = , IconName =  })

    world:(, {
        Text = ,
        Values = (),
        Default = ,
        Searchable = ,
        MaxVisibleDropdownItems = ,
        Tooltip = ,
    })

    world:({
        Text = ,
        Func = ()
            Options.RaceWorld:(())
            Options.RaceWorld:(autoWorld)
        ,
    })

    world:(, {
        Text = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = ,
        Suffix = ,
    })

     extras = tab:({ Side = , Name = , IconName =  })

    extras:(, {
        Text = ,
        Default = ,
    })

    extras:(, {
        Text = ,
    })

    extras:(, {
        Text = ,
        Callback = (value)
             value   overlay 
                overlay = Library:()
              value  overlay 
                overlay:()
                overlay = 
            
        ,
    })


(Tabs.Main)
(Tabs.Clicker)
(Tabs.Race)

  (interval, body)
    .(()
         active   Library.Unloaded 
            ()
            .(interval)
        
    )


(, ()
      Toggles.AutoClick.Value  raceController.State ~=  
        
    
     () > Options.ClickWindow.Value 
        
    
    .(click)
    .( / Options.ClicksPerSecond.Value - )
)

(, ()
      Toggles.AutoJoin.Value  raceController.State ~=  
        
    
     root = ()
     atStart =  root  root.Position.Z < 
     wrongWorld = () ~= ()
     needsJoin = wrongWorld  (atStart   movementController.IsActive)
     needsJoin  .() - lastJoin >= Options.JoinRetry.Value 
        lastJoin = .()
        ()
    
)

(, ()
     Toggles.AutoRun.Value   autoRunController.Activated 
        ()
    
)

(, ()
     Toggles.ForceForward.Value  movementController.IsActive 
        movementService.SendMoveDirection:(.(, , ))
    
)

(, ()
     state = raceController.State
     left = ()

    stateLabel:(.(, state ~=   state  , left))
    worldLabel:( .. (()))
    speedLabel:( .. (speed) .. )
    wallLabel:(.(, wallsReached, wallsTotal))

     overlay 
        overlay:(.(, state, left, wallsReached, wallsTotal))
    
)

  (signal, callback)
    .(connections, signal:(callback))


(raceGenerator.CheckpointReached, (number, total)
    wallsReached = number  wallsReached
    wallsTotal = total  wallsTotal
     Toggles.WallNotify.Value 
        (.(, (number), (total)), )
    
)

(movementService.SyncSpeed, (value)
     (value) ==  
        speed = value
    
)

(raceService.TriggerState, (state)
     state ==  
        wallsReached = 
    
     Toggles.PhaseNotify.Value 
        ( .. (state), )
    
)

(player.Idled, ()
     Toggles.AntiAfk.Value 
        VirtualUser:()
        VirtualUser:(.())
    
)

Library:(()
    active = 
     _, connection  (connections) 
        connection:()
    
     overlay 
        overlay:()
    
     ().AnimeRacingClicker == Library 
        ().AnimeRacingClicker = 
    
)