Auto paint

 STALL_LIMIT = 

 RS     = :()
 player = :().LocalPlayer
 cam    = .CurrentCamera

 DESC_RU = 

 DESC_EN = 

 STALL_RU = 
 STALL_EN = 

 THEME = {
    scrim      = .(,   ,   ),
    card       = .(,  ,  ),
    field      = .(,  ,  ),
    stroke     = .(,  ,  ),
    strokeSoft = .(,  ,  ),
    text       = .(, , ),
    subtext    = .(, , ),
    accent     = .(,  , ),
    onAccent   = .(, , ),
    danger     = .(, ,  ),
    warning    = .(, , ),
}
 FONT      = .Font.Gotham
 FONT_MED  = .Font.GothamMedium
 FONT_BOLD = .Font.GothamBold

  ()
     (cam  cam.ViewportSize)  .(, )


  (baseW, baseH)
     vp = ()
     s = .((vp.X - ) / baseW, (vp.Y - ) / baseH)
     .(s, , )


  (inst, r)
     c = .()
    c.CornerRadius = .(, r  )
    c.Parent = inst
     c


  (inst, col, th)
     s = .()
    s.Color = col  THEME.stroke
    s.Thickness = th  
    s.ApplyStrokeMode = .ApplyStrokeMode.Border
    s.Parent = inst
     s


  (inst, t, r, b, l)
     p = .()
    p.PaddingTop    = .(, t)
    p.PaddingRight  = .(, r  t)
    p.PaddingBottom = .(, b  t)
    p.PaddingLeft   = .(, l  r  t)
    p.Parent = inst
     p


  (parent, gap)
     l = .()
    l.FillDirection = .FillDirection.Vertical
    l.SortOrder     = .SortOrder.LayoutOrder
    l.Padding       = .(, gap  )
    l.Parent        = parent
     l


  (card, sc, baseW, baseH)
      cam   
     conn
    conn = cam:():(()
         card  card.Parent 
            sc.Scale = (baseW, baseH)
         conn 
            conn:()
        
    )
    card.Destroying:(()  conn  conn:()  )


 guis = {}

  ()
     gui = .()
     nm = 
     _ = , .(, )  nm = nm .. .(.(, )) 
    gui.Name           = nm
    gui.ResetOnSpawn   = 
    gui.IgnoreGuiInset = 
    gui.DisplayOrder   = 
    gui.ZIndexBehavior = .ZIndexBehavior.Sibling
     ok = (()
        gui.Parent = (gethui  ())  :()
    )
      ok  gui.Parent = player:() 
    
    guis[#guis+] = gui
    gui.Destroying:(()
         idx = .(guis, gui)
         idx  .(guis, idx) 
    )
    
     gui


  (gui)
     f = .()
    f.Size                 = .(, )
    f.BackgroundColor3     = THEME.scrim
    f.BackgroundTransparency = 
    f.BorderSizePixel      = 
    f.Parent               = gui
     f


  (parent, width, baseH)
     card = .()
    card.AnchorPoint      = .(, )
    card.Position         = .(, )
    card.Size             = .(width, )
    card.AutomaticSize    = .AutomaticSize.Y
    card.BackgroundColor3 = THEME.card
    card.BorderSizePixel  = 
    card.Parent           = parent
    (card, )
    (card, THEME.stroke, )
     sc = .()
    sc.Scale  = (width + , baseH  )
    sc.Parent = card
    (card, sc, width + , baseH  )
     card


  (card, title, accentColor, order)
     holder = .()
    holder.BackgroundTransparency = 
    holder.Size          = .(, , , )
    holder.AutomaticSize = .AutomaticSize.Y
    holder.LayoutOrder   = order  
    holder.Parent        = card
    (holder, )
     tag = .()
    tag.BackgroundTransparency = 
    tag.Size           = .(, , , )
    tag.AutomaticSize  = .AutomaticSize.Y
    tag.Font           = FONT_BOLD
    tag.TextSize       = 
    tag.Text           = 
    tag.TextColor3     = accentColor  THEME.accent
    tag.TextXAlignment = .TextXAlignment.Left
    tag.LayoutOrder    = 
    tag.Parent         = holder
     ttl = .()
    ttl.BackgroundTransparency = 
    ttl.Size           = .(, , , )
    ttl.AutomaticSize  = .AutomaticSize.Y
    ttl.Font           = FONT_BOLD
    ttl.TextSize       = 
    ttl.Text           = title
    ttl.TextColor3     = THEME.text
    ttl.TextWrapped    = 
    ttl.TextXAlignment = .TextXAlignment.Left
    ttl.TextYAlignment = .TextYAlignment.Top
    ttl.LayoutOrder    = 
    ttl.Parent         = holder
     holder


  (card, order)
     d = .()
    d.Size             = .(, , , )
    d.BackgroundColor3 = THEME.strokeSoft
    d.BorderSizePixel  = 
    d.LayoutOrder      = order  
    d.Parent           = card
     d


  (card, text, order)
     l = .()
    l.BackgroundTransparency = 
    l.Size             = .(, , , )
    l.AutomaticSize    = .AutomaticSize.Y
    l.Font             = FONT
    l.TextSize         = 
    l.Text             = text
    l.TextColor3       = THEME.subtext
    l.TextWrapped      = 
    l.TextXAlignment   = .TextXAlignment.Left
    l.TextYAlignment   = .TextYAlignment.Top
    l.LayoutOrder      = order  
    l.Parent           = card
     l


  (parent, text, kind, order)
     b = .()
    b.AutoButtonColor = 
    b.Font            = FONT_MED
    b.TextSize        = 
    b.Text            = text
    b.BorderSizePixel = 
    b.Size            = .(, , , )
    b.LayoutOrder     = order  
    b.Parent          = parent
    (b, )
     kind ==  
        b.BackgroundColor3 = THEME.accent
        b.TextColor3       = THEME.onAccent
    
        b.BackgroundColor3 = THEME.field
        b.TextColor3       = THEME.text
        (b, THEME.stroke, )
    
     b


  (card, order)
     row = .()
    row.BackgroundTransparency = 
    row.Size        = .(, , , )
    row.LayoutOrder = order  
    row.Parent      = card
     h = .()
    h.FillDirection       = .FillDirection.Horizontal
    h.HorizontalAlignment = .HorizontalAlignment.Center
    h.VerticalAlignment   = .VerticalAlignment.Center
    h.SortOrder           = .SortOrder.LayoutOrder
    h.Padding             = .(, )
    h.Parent              = row
     row


  (title, body, color)
     gui  = ()
    (gui)
     card = (gui, , )
    (card, )
    (card, )
    (card, title, color, )
    (card, )
    (card, body, )
     ok = (card, , , )
    
     ev = .()
    ok.MouseButton1Click:(() ev:() )
    ev.Event:()
    ev:()
    gui:()


  (title, body)
     gui  = ()
    (gui)
     card = (gui, , )
    (card, )
    (card, )
    (card, title, THEME.accent, )
    (card, )
    (card, body, )
     row  = (card, )
     no   = (row, ,  , )
    no.Size    = .(, -, , )
     yes  = (row, , ,   )
    yes.Size   = .(, -, , )
    
     ev = .()
    yes.MouseButton1Click:(() ev:()  )
    no.MouseButton1Click:(()  ev:() )
     result = ev.Event:()
    ev:()
    gui:()
    
     result


  ()
     gui  = ()
    (gui)
     card = .()
    card.AnchorPoint      = .(, )
    card.Position         = .(, )
    card.Size             = .(, )
    card.BackgroundColor3 = THEME.card
    card.BorderSizePixel  = 
    card.Parent           = gui
    (card, )
    (card, THEME.stroke, )
     sc = .()
    sc.Scale  = (, )
    sc.Parent = card
    (card, sc, , )
    (card, )
    
     tag = .()
    tag.BackgroundTransparency = 
    tag.Position       = .(, )
    tag.Size           = .(, , , )
    tag.Font           = FONT_BOLD
    tag.TextSize       = 
    tag.Text           = 
    tag.TextColor3     = THEME.accent
    tag.TextXAlignment = .TextXAlignment.Left
    tag.Parent         = card
    
     title = .()
    title.BackgroundTransparency = 
    title.Position       = .(, )
    title.Size           = .(, , , )
    title.Font           = FONT_BOLD
    title.TextSize       = 
    title.Text           = 
    title.TextColor3     = THEME.text
    title.TextXAlignment = .TextXAlignment.Left
    title.Parent         = card
    
     seg = .()
    seg.Position         = .(, )
    seg.Size             = .(, , , )
    seg.BackgroundColor3 = THEME.field
    seg.BorderSizePixel  = 
    seg.Parent           = card
    (seg, )
    (seg, THEME.strokeSoft, )
    (seg, )
    
     ruBtn = .()
    ruBtn.AnchorPoint     = .(, )
    ruBtn.Position        = .(, , , )
    ruBtn.Size            = .(, -, , )
    ruBtn.AutoButtonColor = 
    ruBtn.Font            = FONT_MED
    ruBtn.TextSize        = 
    ruBtn.Text            = 
    ruBtn.BorderSizePixel = 
    ruBtn.Parent          = seg
    (ruBtn, )
    
     enBtn = .()
    enBtn.AnchorPoint     = .(, )
    enBtn.Position        = .(, , , )
    enBtn.Size            = .(, -, , )
    enBtn.AutoButtonColor = 
    enBtn.Font            = FONT_MED
    enBtn.TextSize        = 
    enBtn.Text            = 
    enBtn.BorderSizePixel = 
    enBtn.Parent          = seg
    (enBtn, )
    
     scroll = .()
    scroll.Position                   = .(, )
    scroll.Size                       = .(, , , -( + ))
    scroll.BackgroundColor3           = THEME.field
    scroll.BorderSizePixel            = 
    scroll.ScrollBarThickness         = 
    scroll.ScrollBarImageColor3       = THEME.subtext
    scroll.ScrollBarImageTransparency = 
    scroll.ScrollingDirection         = .ScrollingDirection.Y
    scroll.CanvasSize                 = .(, , , )
    scroll.AutomaticCanvasSize        = .AutomaticSize.Y
    scroll.Parent                     = card
    (scroll, )
    (scroll, THEME.strokeSoft, )
    (scroll, )
    
     body = .()
    body.BackgroundTransparency = 
    body.Size           = .(, , , )
    body.AutomaticSize  = .AutomaticSize.Y
    body.Font           = FONT
    body.TextSize       = 
    body.Text           = DESC_RU
    body.TextColor3     = THEME.text
    body.TextWrapped    = 
    body.TextXAlignment = .TextXAlignment.Left
    body.TextYAlignment = .TextYAlignment.Top
    body.Parent         = scroll
    
      (lang)
         lang ==  
            body.Text              = DESC_RU
            ruBtn.BackgroundColor3 = THEME.accent; ruBtn.TextColor3 = THEME.onAccent
            enBtn.BackgroundColor3 = THEME.field;  enBtn.TextColor3 = THEME.subtext
        
            body.Text              = DESC_EN
            enBtn.BackgroundColor3 = THEME.accent; enBtn.TextColor3 = THEME.onAccent
            ruBtn.BackgroundColor3 = THEME.field;  ruBtn.TextColor3 = THEME.subtext
        
    
    ()
    ruBtn.MouseButton1Click:(() () )
    enBtn.MouseButton1Click:(() () )
    
     okBtn = .()
    okBtn.AnchorPoint      = .(, )
    okBtn.Position         = .(, , , )
    okBtn.Size             = .(, , , )
    okBtn.AutoButtonColor  = 
    okBtn.Font             = FONT_MED
    okBtn.TextSize         = 
    okBtn.Text             = 
    okBtn.BackgroundColor3 = THEME.accent
    okBtn.TextColor3       = THEME.onAccent
    okBtn.BorderSizePixel  = 
    okBtn.Parent           = card
    (okBtn, )
    
     ev = .()
    okBtn.MouseButton1Click:(() ev:() )
    ev.Event:()
    ev:()
    gui:()


  ()
     _, g  (guis)  (() g:() ) 
    .(guis)


  (title, body, color)
    (title, body, color)
    ()


 wantInfo = (, )
 wantInfo  () 

 run = (, )
  run   

 claimedBase = 
 bases = :()
 bases 
     _, b  (bases:()) 
         b:()  b:() == player.UserId 
            claimedBase = b
            
        
    


  claimedBase 
    (,
        ,
        THEME.warning)
    


 folder     = :((player.UserId))
 canvasBase = folder  folder:()

  canvasBase 
    (,
        ,
        THEME.warning)
    


 ColorPixel      = RS.RemoteEvents.ColorPixel
 SetCurrentColor = RS.RemoteEvents.SetCurrentColor
 GetPixelInfo    = RS.RemoteFunctions.GetPixelInfo
 CheckIfPainted  = RS.RemoteFunctions.CheckIfPainted

 W      = canvasBase.Size.X * 
 H      = canvasBase.Size.Z * 
 RADIUS = player:()  
 STEP   = .(RADIUS * )

 pixelMap = GetPixelInfo:()

  pixelMap 
    (,
        ,
        THEME.warning)
    


 hasPixels = 
 _, rows  (pixelMap) 
     _, ci  (rows) 
         ci ~=   hasPixels =   
    
     hasPixels   


  hasPixels 
    (,
        ,
        THEME.warning)
    


 char = player.Character  player.CharacterAdded:()
 hrp  = char:(, )
  hrp 
    (,
        ,
        THEME.danger)
    


cam.CameraType = .CameraType.Scriptable
cam.CFrame = .(
    canvasBase.Position + .(, .(canvasBase.Size.X, canvasBase.Size.Z) * , ),
    canvasBase.Position
)

  (col, row)
     lx = (col - ) / W * canvasBase.Size.X - canvasBase.Size.X / 
     lz = canvasBase.Size.Z /  - (row - ) / H * canvasBase.Size.Z
     canvasBase.CFrame:(.(lx, , lz))


hrp.Anchored = 

 lastRem = .huge
 stalls  = 

 round = ,  
     pm   = CheckIfPainted:()  {}
     plan = {}
     rem  = 

     col, rows  (pixelMap) 
         row, ci  (rows) 
             ci ~=    (pm[col]  pm[col][row] == ) 
                rem += 
                 gc  = .(col / STEP)
                 gr  = .(row / STEP)
                 ac  = .((gc-)*STEP + .(STEP/), , W)
                 ar  = .((gr-)*STEP + .(STEP/), , H)
                 key = gc *  + gr
                  plan[ci]  plan[ci] = {} 
                  plan[ci][key]  plan[ci][key] = {ac=ac, ar=ar, px={}} 
                 t = plan[ci][key].px
                t[#t+] = {col, row}
            
        
    

     rem ==  
        hrp.Anchored   = 
        cam.CameraType = .CameraType.Custom
        ()
        
    

     rem >= lastRem  stalls +=   stalls =  
    lastRem = rem
     stalls >= STALL_LIMIT 
        hrp.Anchored   = 
        cam.CameraType = .CameraType.Custom
        (, STALL_RU ..  .. STALL_EN, THEME.danger)
        
    

     ops = 
     ci, cells  (plan) 
        SetCurrentColor:(ci)
         _, cell  (cells) 
            hrp.CFrame = .((cell.ac, cell.ar)) * hrp.CFrame.Rotation
            ColorPixel:(cell.px)
            ops += 
             ops %  ==   .() 
        
    

    .()


hrp.Anchored   = 
cam.CameraType = .CameraType.Custom
(,
    ,
    THEME.warning)