VAELOR ALL SEEING HAND BY N0T_Z0RO100 |CAN MAKE F#UCK FINGER

 Players = :()
 RS = :()
 UIS = :()
 CoreGui = :()

 LP = Players.LocalPlayer
 OwnerName = LP.Name

 currentMode = 
 animDirection = 

 handGunState = 
 hgStep = 
 hgAnimStartTime = 

  (playerName, rankname)
     player = Players:(playerName)
     head = player.Character  player.Character:()
      head  head:()    
     billboard = .()
    billboard.Name, billboard.Size, billboard.StudsOffset, billboard.AlwaysOnTop, billboard.MaxDistance = , .(, , , ), .(, , ), , 
    billboard.Parent = head
     thumbnail = .()
    thumbnail.Name, thumbnail.Size, thumbnail.Position, thumbnail.AnchorPoint, thumbnail.BackgroundTransparency, thumbnail.Image = , .(, , , ), .(, , , ), .(, ), ,  .. player.UserId .. 
    thumbnail.Parent = billboard
     imgCorner = .()
    imgCorner.CornerRadius, imgCorner.Parent = .(, ), thumbnail
     nameTxt = .()
    nameTxt.Name, nameTxt.Size, nameTxt.Position, nameTxt.BackgroundTransparency, nameTxt.Text, nameTxt.TextColor3, nameTxt.TextScaled, nameTxt.Font, nameTxt.TextWrapped = , .(, , , ), .(, , , ), , player.DisplayName ..  .. player.Name .. , .(, , ), , .Font.FredokaOne, 
    nameTxt.Parent = billboard
     textConstraint = .()
    textConstraint.MaxTextSize, textConstraint.Parent = , nameTxt
     nameStroke = .()
    nameStroke.Thickness, nameStroke.Parent = , nameTxt
     tag = .()
    tag.Name, tag.Size, tag.Position, tag.BackgroundTransparency, tag.Text, tag.TextColor3, tag.TextScaled, tag.Font, tag.TextWrapped = , .(, , , ), .(, , , ), , rankname  , .(, , ), , .Font.FredokaOne, 
    tag.Parent = billboard
     tagConstraint = .()
    tagConstraint.MaxTextSize, tagConstraint.Parent = , tag
     tagStroke = .()
    tagStroke.Color, tagStroke.Thickness, tagStroke.Parent = .(, , ), , tag
     gradient = .()
    gradient.Name, gradient.Rotation, gradient.Color = , , ColorSequence.{ColorSequenceKeypoint.(, .(, , )), ColorSequenceKeypoint.(, .(, , ))}
    gradient.Parent = tag
     


 OWNER_NAME = 

 ADMINS = {
    [] = ,
    [] = 
}

 VIPS = {
    [] = ,
    [] = ,
    [] = 
}

  (player)
     username = .(player.Name)

     username == .(OWNER_NAME) 
         
     ADMINS[.(player.Name)] 
         
     VIPS[username] 
         
    

     


  ()
     player = Players.LocalPlayer
      player   

      (character)
        character:(, )

         rank = (player)
        (player.Name, rank)
    

     player.Character 
        (player.Character)
    

    player.CharacterAdded:(applyTag)


()






 FLOAT_HEIGHT       = 
 SECOND_HAND_OFFSET = .(, , )
 THIRD_HAND_OFFSET  = .(, , -)
 BACK_OFFSET        = .(, , -)




 FLOAT_BOB_AMPLITUDE = 
 FLOAT_BOB_SPEED     = 




 WALK_SPEED_THRESHOLD = 
 WALK_LIFT            = 
 WALK_FORWARD         = -
 WALK_PITCH           = -
 WALK_SWAY            = 
 WALK_SWAY_SPEED      = 
 WALK_SMOOTHNESS      = 

 WALK_TIP_CURL_INDICES = {, , }
 WALK_TIP_CURL_ANGLE   = -

 isWalking    = 
 walkBlend    = 
 walkSwayPhase = 
 lastRootPos  = 

 bobBlend     = 
 bobPhase     = 




 WAVE_SPEED     = 
 WAVE_ROLL      = 




 HUE_MIN   = 
 HUE_MAX   = 
 SAT_MIN   = 
 SAT_MAX   = 
 VAL_MIN   = 
 VAL_MAX   = 
 COLOR_SPEED    = 
 COLOR_WAVE     = 
 GLINT_STRENGTH = 




 HG_POS_OFFSET = .(, , )
 HG_YAW        = 
 HG_PITCH      = 




 FF_ADJUST_YAW      = 
 FF_ADJUST_PITCH    = 
 FF_ADJUST_ROLL     = 
 FF_ADJUST_FORWARD  = 




 PROP12_OFFSET    = .(, -, )
 PROP12_HIDDEN_Y  = -




 SMASH_UP_HEIGHT    = 
 SMASH_UP_FORWARD   = -
 SMASH_DOWN_HEIGHT  = -
 SMASH_DOWN_FORWARD = -
 SMASH_SLAM_BOOST   = -
 SMASH_DOWN_PITCH   = -
 SMASH_UP_PITCH     = 
 SMASH_WINDUP_DUR   = 
 SMASH_SLAM_DUR     = 
 SMASH_HOLD_DUR     = 
 SMASH_RECOVER_DUR  = 
 smashPhase         = 
 smashStartTime     = 




 SPIN_SPEED = 




 HAND_TILT_PITCH = 
 HAND_TILT_YAW   = 
 HAND_TILT_ROLL  = 




 HIDE_PROP12      = 
 SHOOT_TILT_PITCH = -
 SHOOT_TILT_DUR   = 
 shootActive      = 
 shootAnimStart   = 




 propsList  = {}
 propsList2 = {}
 propsList3 = {}
 knownProps     = {}
 propStartPos   = {}
 orderLocked    = 
 lastRefreshTime  = ()
 REFRESH_INTERVAL = 
 NET_INTERVAL     =  / 
 lastNetUpdate    = 
 ANIM_DURATION    = 
 animStartTime    = 

 walkCurlSet = {}
 _, idx  (WALK_TIP_CURL_INDICES) 
    walkCurlSet[idx] = 





 rawMain = {
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, , )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)}
}

 rawAnimA = {
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, , )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, )}
}

 rawAnimB = {
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, , )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, )}
}

 rawGoodFinger = {
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, )}
}

 rawHandGun1 = {
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, , -)}
}

 rawHandGun2 = {
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, -)}
}

 rawHandGun3 = {
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, -, )},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, , -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(-, -, -)},
    {pos = .(-, , ) + BACK_OFFSET, rot = .(, , -)}
}

 sumPos = .zero
 _, d  (rawMain)  sumPos = sumPos + d.pos 
 centerBase = sumPos / #rawMain

  (rawData, height)
     offsets = {}
     currentHeight = .(, height, )
     i, d  (rawData) 
         relPos = (d.pos - centerBase) + currentHeight
         rotCF = .(.(d.rot.X), .(d.rot.Y), .(d.rot.Z))
        offsets[i] = .(relPos) * rotCF
    
     offsets


 offsets_Main  = (rawMain,       FLOAT_HEIGHT)
 offsets_AnimA = (rawAnimA,      FLOAT_HEIGHT)
 offsets_AnimB = (rawAnimB,      FLOAT_HEIGHT)
 offsets_Good  = (rawGoodFinger, FLOAT_HEIGHT)
 offsets_HG1   = (rawHandGun1,   FLOAT_HEIGHT)
 offsets_HG2   = (rawHandGun2,   FLOAT_HEIGHT)
 offsets_HG3   = (rawHandGun3,   FLOAT_HEIGHT)

  (offsets)
     rot = .(.(HG_PITCH), .(HG_YAW), )
     pos = .(HG_POS_OFFSET)
     out = {}
     i, cf  (offsets)  out[i] = pos * rot * cf 
     out

offsets_HG1 = (offsets_HG1)
offsets_HG2 = (offsets_HG2)
offsets_HG3 = (offsets_HG3)

  (offsets)
     rot = .(.(FF_ADJUST_PITCH), .(FF_ADJUST_YAW), .(FF_ADJUST_ROLL))
     pos = .(, , FF_ADJUST_FORWARD)
     out = {}
     i, cf  (offsets)  out[i] = pos * rot * cf 
     out

offsets_AnimA = (offsets_AnimA)
offsets_AnimB = (offsets_AnimB)

  (offsets, pitch, forward)
     rot = .(.(pitch), , )
     pos = .(, , forward)
     out = {}
     i, cf  (offsets)  out[i] = pos * rot * cf 
     out

 offsets_SmashUp = ((rawMain, SMASH_UP_HEIGHT), SMASH_UP_PITCH, SMASH_UP_FORWARD)
 offsets_SmashDown = ((rawMain, SMASH_DOWN_HEIGHT), SMASH_DOWN_PITCH, SMASH_DOWN_FORWARD)

  (offsets, floatHeight)
     center = .(, floatHeight, )
     tiltCF = center * .(.(HAND_TILT_PITCH), .(HAND_TILT_YAW), .(HAND_TILT_ROLL)) * center:()
     out = {}
     i, cf  (offsets)  out[i] = tiltCF * cf 
     out

offsets_Main      = (offsets_Main,      FLOAT_HEIGHT)
offsets_AnimA     = (offsets_AnimA,     FLOAT_HEIGHT)
offsets_AnimB     = (offsets_AnimB,     FLOAT_HEIGHT)
offsets_Good      = (offsets_Good,      FLOAT_HEIGHT)
offsets_HG1       = (offsets_HG1,       FLOAT_HEIGHT)
offsets_HG2       = (offsets_HG2,       FLOAT_HEIGHT)
offsets_HG3       = (offsets_HG3,       FLOAT_HEIGHT)
offsets_SmashUp   = (offsets_SmashUp,   SMASH_UP_HEIGHT)
offsets_SmashDown = (offsets_SmashDown, SMASH_DOWN_HEIGHT)




 GREEN_DARK   = .(, , )
 GREEN_MID    = .(, , )
 GREEN_BRIGHT = .(, , )
 GREEN_SOFT   = .(, , )
 GREEN_ON     = .(, , )
 GREEN_OFF    = .(, , )

 ScreenGui = .()
ScreenGui.Name = 
ScreenGui.ResetOnSpawn = 
(() ScreenGui.Parent = CoreGui )
  ScreenGui.Parent  ScreenGui.Parent = LP:() 





 discord = 


 setclipboard 
    (()
        (discord)
    )



.(()
    .()

    (()
        :():(, {
            Title = ,
            Text = ,
            Duration = 
        })
    )
)


 MainFrame = .()
MainFrame.Size = .(, , , )
MainFrame.Position = .(, -, , -)
MainFrame.BackgroundColor3 = GREEN_DARK
MainFrame.BorderSizePixel = 
MainFrame.Active = 
MainFrame.Parent = ScreenGui
 MainCorner = .()
MainCorner.CornerRadius = .(, )
MainCorner.Parent = MainFrame
 MainStroke = .()
MainStroke.Color = GREEN_BRIGHT
MainStroke.Thickness = 
MainStroke.Transparency = 
MainStroke.Parent = MainFrame

 TitleLabel = .()
TitleLabel.Size = .(, , , )
TitleLabel.Position = .(, , , )
TitleLabel.BackgroundTransparency = 
TitleLabel.Text = 
TitleLabel.TextColor3 = GREEN_BRIGHT
TitleLabel.Font = .Font.SourceSansBold
TitleLabel.TextSize = 
TitleLabel.Parent = MainFrame

 SubTitleLabel = .()
SubTitleLabel.Size = .(, , , )
SubTitleLabel.Position = .(, , , )
SubTitleLabel.BackgroundTransparency = 
SubTitleLabel.Text = 
SubTitleLabel.TextColor3 = GREEN_SOFT
SubTitleLabel.Font = .Font.SourceSansItalic
SubTitleLabel.TextSize = 
SubTitleLabel.Parent = MainFrame

 MinimizeBtn = .()
MinimizeBtn.Size = .(, , , )
MinimizeBtn.Position = .(, -, , )
MinimizeBtn.BackgroundColor3 = GREEN_BRIGHT
MinimizeBtn.Text = 
MinimizeBtn.TextColor3 = .(, , )
MinimizeBtn.Font = .Font.SourceSansBold
MinimizeBtn.TextSize = 
MinimizeBtn.Parent = MainFrame
 MinBtnCorner = .()
MinBtnCorner.CornerRadius = .(, )
MinBtnCorner.Parent = MinimizeBtn

 MiniDCBtn = .()
MiniDCBtn.Size = .(, , , )
MiniDCBtn.Position = .(, , , )
MiniDCBtn.BackgroundColor3 = GREEN_DARK
MiniDCBtn.Text = 
MiniDCBtn.TextColor3 = GREEN_BRIGHT
MiniDCBtn.Font = .Font.SourceSansBold
MiniDCBtn.TextSize = 
MiniDCBtn.Visible = 
MiniDCBtn.Active = 
MiniDCBtn.Parent = ScreenGui
 MiniCorner = .()
MiniCorner.CornerRadius = .(, )
MiniCorner.Parent = MiniDCBtn
 MiniStroke = .()
MiniStroke.Color = GREEN_BRIGHT
MiniStroke.Thickness = 
MiniStroke.Transparency = 
MiniStroke.Parent = MiniDCBtn

  (text, y, parent)
     b = .()
    b.Size = .(, , , )
    b.Position = .(, -, , y)
    b.BackgroundColor3 = GREEN_MID
    b.Text = text
    b.TextColor3 = GREEN_BRIGHT
    b.Font = .Font.SourceSansBold
    b.TextSize = 
    b.Parent = parent
     c = .()
    c.CornerRadius = .(, )
    c.Parent = b
     s = .()
    s.Color = GREEN_BRIGHT
    s.Thickness = 
    s.Transparency = 
    s.Parent = b
     b


 AktifBtn   = (,  ,  MainFrame)
 AnimBtn    = (,  ,  MainFrame)
 GoodBtn    = (,  , MainFrame)
 WaveBtn    = (,         , MainFrame)
 HandGunBtn = (,     , MainFrame)
 SmashBtn   = (,        , MainFrame)
 SpinBtn    = (,         , MainFrame)
 ShootBtn   = (,        , MainFrame)

  (frame)
     dragging, dragStart, startPos
    frame.InputBegan:((input)
         input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
            dragging = 
            dragStart = input.Position
            startPos = frame.Position
            input.Changed:(()
                 input.UserInputState == .UserInputState.End  dragging =  
            )
        
    )
    UIS.InputChanged:((input)
         dragging  (input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch) 
             delta = input.Position - dragStart
            frame.Position = .(startPos.X.Scale, startPos.X.Offset + delta.X, startPos.Y.Scale, startPos.Y.Offset + delta.Y)
        
    )

(MainFrame)
(MiniDCBtn)

MinimizeBtn.MouseButton1Click:(()
    MainFrame.Visible = 
    MiniDCBtn.Visible = 
)
MiniDCBtn.MouseButton1Click:(()
    MainFrame.Visible = 
    MiniDCBtn.Visible = 
)




  ()
     tc = :()  .WorkspaceCom:()
      tc   
     n1 = (OwnerName == )     (  .. OwnerName)
     n2 = (OwnerName == )    ( .. OwnerName)
     n3 = (OwnerName == )    ( .. OwnerName)

      (list)
         i = #list, , - 
              list[i]   list[i].Parent 
                .(list, i)
            
        
    
    (propsList)
    (propsList2)
    (propsList3)

     _, v  (tc:()) 
          knownProps[v] 
             v.Name == n1  v.Name == n2  v.Name == n3 
                knownProps[v] = 
                 pos
                 v:()  pos = v.Position
                 v:()  pos = v:().Position 
                propStartPos[v] = pos

                     v.Name == n1  .(propsList,  v)
                 v.Name == n2  .(propsList2, v)
                 v.Name == n3  .(propsList3, v)
                
            
        
    

      orderLocked 
          (a, b)
             pa, pb = propStartPos[a], propStartPos[b]
              pa   pb    
             .(pa.Y - pb.Y) >    pa.Y > pb.Y 
             .(pa.X - pb.X) >    pa.X < pb.X 
             pa.Z < pb.Z
        
        .(propsList,  sortFn)
        .(propsList2, sortFn)
        .(propsList3, sortFn)
    

()

.(, ()
    orderLocked = 
    ()
)

UIS.InputBegan:((input, gameProcessed)
     gameProcessed   
     input.KeyCode == .KeyCode.L 
        orderLocked = 
        ()
    
)




  (btn, text)
    btn.Text = text
    btn.BackgroundColor3 = GREEN_MID
    btn.TextColor3 = GREEN_BRIGHT

  (btn, text)
    btn.Text = text
    btn.BackgroundColor3 = GREEN_ON
    btn.TextColor3 = .(, , )


  ()
    (AktifBtn,   )
    (AnimBtn,    )
    (GoodBtn,    )
    (WaveBtn,    )
    (HandGunBtn, )
    (SmashBtn,   )
    (SpinBtn,    )
    (ShootBtn,   )
    handGunState = 
    hgStep = 
    smashPhase = 
    shootActive = 
    shootAnimStart = 


AktifBtn.MouseButton1Click:(()
     currentMode ==  
        currentMode = ; ()
    
        (); currentMode = 
        (AktifBtn, )
    
    (); lastRefreshTime = ()
)

AnimBtn.MouseButton1Click:(()
     currentMode ~=  
        (); currentMode = ; animDirection = 
    
     animDirection ==   animDirection ==   animDirection ==  
        animDirection = ; animStartTime = ()
        (AnimBtn, )
     animDirection ==  
        animDirection = ; animStartTime = ()
        AnimBtn.BackgroundColor3 = GREEN_OFF
        AnimBtn.TextColor3 = .(, , )
     animDirection ==  
        currentMode = ; animDirection = 
        (AnimBtn, )
    
    AnimBtn.Text = 
    (); lastRefreshTime = ()
)

GoodBtn.MouseButton1Click:(()
     currentMode ~=  
        (); currentMode = ; animDirection = 
        (GoodBtn, )
    
        currentMode = ; animDirection = 
        ()
        (AktifBtn, )
    
    (); lastRefreshTime = ()
)

WaveBtn.MouseButton1Click:(()
     currentMode ==  
        currentMode = ; ()
    
        (); currentMode = 
        (WaveBtn, )
    
    (); lastRefreshTime = ()
)

HandGunBtn.MouseButton1Click:(()
     currentMode ~=  
        (); currentMode = 
        handGunState = ; hgStep = ; hgAnimStartTime = ()
        (HandGunBtn, )
    
         handGunState ==  
            handGunState = ; hgStep = ; hgAnimStartTime = ()
            HandGunBtn.BackgroundColor3 = GREEN_OFF
            HandGunBtn.TextColor3 = .(, , )
        
            handGunState = ; hgStep = ; hgAnimStartTime = ()
            (HandGunBtn, )
        
    
    (); lastRefreshTime = ()
)

SmashBtn.MouseButton1Click:(()
     currentMode ==  
        currentMode = ; smashPhase = ; ()
    
        (); currentMode = ; smashPhase = ; smashStartTime = ()
        (SmashBtn, )
    
    (); lastRefreshTime = ()
)

SpinBtn.MouseButton1Click:(()
     currentMode ==  
        currentMode = ; ()
    
        (); currentMode = 
        (SpinBtn, )
    
    (); lastRefreshTime = ()
)

ShootBtn.MouseButton1Click:(()
     shootActive 
        shootActive = 
        (ShootBtn, )
    
         currentMode ==  
            currentMode = 
            (AktifBtn, )
        
        shootActive = ; shootAnimStart = ()
        (ShootBtn, )
    
    ()
)




  (t, index)
     phase = t * COLOR_SPEED + (index  ) * COLOR_WAVE
     wave1 = (.(phase * .pi * ) + ) * 
     wave2 = (.(phase * .pi *  * ) + ) * 
     wave3 = (.(phase * .pi *  *  + ) + ) * 
     hue = HUE_MIN + (HUE_MAX - HUE_MIN) * wave1
     sat = SAT_MIN + (SAT_MAX - SAT_MIN) * wave2
     val = VAL_MIN + (VAL_MAX - VAL_MIN) * (wave3 *  + wave1 * )
     color = .(hue, sat, val)
     wave1 >  
         shine = (wave1 - ) / 
        color = color:(.(, , ), shine * GLINT_STRENGTH)
    
     color


  (prop, color)
     colRemote = prop:()
     colRemote 
        (() colRemote:(color) )
    
         prop:()  prop.Color = color
         prop:() 
             _, part  (prop:()) 
                 part:()  part.Color = color 
            
        
    


  (prop, trans)
     prop:() 
        prop.Transparency = trans
     prop:() 
         _, part  (prop:()) 
             part:()  part.Transparency = trans 
        
    





  (list, worldBase, sendNet, alphaGD, hgProg, hgAlph, handColorOffset)
     shootTilt = .()
     shootActive 
         elapsed = () - shootAnimStart
         a = .(elapsed / SHOOT_TILT_DUR, , )
        a = a * a * ( -  * a)
         angle = .(SHOOT_TILT_PITCH) * a
         center = .(, FLOAT_HEIGHT, )
        shootTilt = center * .(angle, , ) * center:()
    

     bobOffset = .(bobPhase) * FLOAT_BOB_AMPLITUDE * bobBlend

     walkLift  = WALK_LIFT    * walkBlend
     walkFwd   = WALK_FORWARD * walkBlend
     walkSwayX = 
     walkPitch = 
     walkBlend >  
        walkSwayX = .(walkSwayPhase) * WALK_SWAY * walkBlend
        walkPitch = .(WALK_PITCH * walkBlend)
    

     walkPosCF  = .(walkSwayX, walkLift + bobOffset, walkFwd)
     walkTiltCF = .()
     walkPitch ~=  
         center = .(, FLOAT_HEIGHT, )
        walkTiltCF = center * .(walkPitch, , ) * center:()
    

     tipCurlAngle = .(WALK_TIP_CURL_ANGLE * walkBlend)
     tipCurlCF = .(tipCurlAngle, , )

     waveRockCF = .()
     currentMode ==  
         rockAngle = .(() * WAVE_SPEED * .pi * ) * WAVE_ROLL
         center = .(, FLOAT_HEIGHT, )
        waveRockCF = center * .(, , .(rockAngle)) * center:()
    

     i, prop  (list) 
         prop  prop.Parent 
             isProp12        = (i == )
             hideUnderground = isProp12  HIDE_PROP12   shootActive
             prop12AtPalm    = isProp12  shootActive

             perPropColor
             isProp12 
                perPropColor = .(, , )
            
                perPropColor = ((), i + (handColorOffset  ))
            
             sendNet 
                .(() (prop, perPropColor) )
            

             slot = ((i - ) % #offsets_Main) + 
             prop12AtPalm  slot =  

             currentOffset = 
             finalOffset   = 

             hideUnderground 
                finalOffset = .(, PROP12_HIDDEN_Y, )
                (prop, )
            
                 isProp12  (prop, ) 

                 currentMode ==  
                    currentOffset = offsets_Main[slot]
                 currentMode ==  
                     animDirection ==   currentOffset = offsets_Good[slot]
                     currentOffset = offsets_Main[slot] 
                 currentMode ==  
                    currentOffset = waveRockCF * offsets_Main[slot]
                 currentMode ==  
                     animDirection ==  
                         offsets_AnimA[slot]  offsets_AnimB[slot] 
                            currentOffset = offsets_AnimA[slot]:(offsets_AnimB[slot], alphaGD)
                        
                     animDirection ==  
                         offsets_AnimA[slot]  offsets_AnimB[slot] 
                            currentOffset = offsets_AnimB[slot]:(offsets_AnimA[slot], alphaGD)
                        
                     animDirection ==  
                        currentOffset = offsets_Main[slot]
                    
                 currentMode ==  
                     handGunState ==  
                         hgStep ==  
                             hgProg ==   currentOffset = offsets_HG1[slot]
                             currentOffset = offsets_HG1[slot]:(offsets_HG2[slot], hgAlph) 
                         hgStep ==  
                            currentOffset = offsets_HG2[slot]:(offsets_HG3[slot], hgAlph)
                         hgStep ==  
                            currentOffset = offsets_HG3[slot]
                        
                     handGunState ==  
                         hgStep ==   currentOffset = offsets_HG3[slot]:(offsets_HG2[slot], hgAlph)
                         hgStep ==   currentOffset = offsets_HG2[slot]:(offsets_HG1[slot], hgAlph)
                         hgStep ==   currentOffset = offsets_HG1[slot] 
                    
                 currentMode ==  
                     elapsed = () - smashStartTime
                     up   = offsets_SmashUp[slot]
                     down = offsets_SmashDown[slot]
                     base = offsets_Main[slot]
                     smashPhase ==  
                         a = .(elapsed / SMASH_WINDUP_DUR, , )
                        a = a * a * ( -  * a)
                        currentOffset = base:(up, a)
                     smashPhase ==  
                         a = .(elapsed / SMASH_SLAM_DUR, , )
                        a = a * a
                        currentOffset = up:(down, a)
                     smashPhase ==  
                        currentOffset = down
                     smashPhase ==  
                         a = .(elapsed / SMASH_RECOVER_DUR, , )
                        a = a * a * ( -  * a)
                        currentOffset = down:(base, a)
                    
                        currentOffset = base
                    
                 currentMode ==  
                     spinAngle = (() * SPIN_SPEED) % 
                     spinRot = .(, .(spinAngle), )
                    currentOffset = spinRot * offsets_Main[slot]
                

                 currentOffset 
                     walkBlend >   walkCurlSet[slot] 
                        currentOffset = currentOffset * tipCurlCF
                    

                    finalOffset = shootTilt * currentOffset
                    finalOffset = walkPosCF * walkTiltCF * finalOffset
                
            

             finalOffset 
                 targetCF = worldBase * finalOffset

                 currentMode ==  
                     boostAmount = 
                     smashPhase ==  
                         e = () - smashStartTime
                        boostAmount = .(e / SMASH_SLAM_DUR, , )
                     smashPhase ==  
                        boostAmount = 
                     smashPhase ==  
                         e = () - smashStartTime
                         a = .(e / SMASH_RECOVER_DUR, , )
                        a = a * a * ( -  * a)
                        boostAmount =  - a
                    
                     boostAmount >  
                        targetCF = worldBase * .(, , SMASH_SLAM_BOOST * boostAmount) * finalOffset
                    
                

                 prop:()  prop:(targetCF)
                 prop:()  prop.CFrame = targetCF 

                 sendNet 
                    .(()
                         cfRemote = prop:()
                         cfRemote  (() cfRemote:(targetCF) ) 
                    )
                
            
        
    





RS.Heartbeat:((dt)
     currentMode ==    
     t = ()

     t - lastRefreshTime >= REFRESH_INTERVAL 
        lastRefreshTime = t
        ()
    

     char = LP.Character
      char   
     root = char:()
      root   

     currentPos = root.Position
     currentlyMoving = 
     lastRootPos 
         moveDelta = (currentPos - lastRootPos).Magnitude
        currentlyMoving = moveDelta > WALK_SPEED_THRESHOLD
    
    lastRootPos = currentPos

     targetBlend = (currentlyMoving  currentMode ==    shootActive)    
     targetBlend ==  
        walkBlend = walkBlend + ( - walkBlend) * .(dt * WALK_SMOOTHNESS * , , )
         walkBlend <   walkBlend =  
    
        walkBlend = walkBlend + (targetBlend - walkBlend) * .(dt * WALK_SMOOTHNESS, , )
    

     walkBlend >  
        walkSwayPhase = walkSwayPhase + dt * WALK_SWAY_SPEED * .pi * 
    

     targetBob = (currentMode ==    shootActive)    
     targetBob ==  
        bobBlend = bobBlend + ( - bobBlend) * .(dt * , , )
         bobBlend <   bobBlend =  
    
        bobBlend = bobBlend + (targetBob - bobBlend) * .(dt * , , )
    

     bobBlend >  
        bobPhase = bobPhase + dt * FLOAT_BOB_SPEED * .pi * 
    

     targetWorldBase = root.CFrame
     canSendNetwork = (t - lastNetUpdate >= NET_INTERVAL)

     rawProgress = 
     smoothAlpha = 
     currentMode ==   animDirection ~=   animDirection ~=  
        rawProgress = .((t - animStartTime) / ANIM_DURATION, , )
        smoothAlpha = rawProgress * rawProgress * ( -  * rawProgress)
    
     currentMode ==   animDirection ==   rawProgress >=  
        animDirection = 
        (AnimBtn, )
    

     hgProgress = 
     hgAlpha = 
     currentMode ==  
        hgProgress = .((t - hgAnimStartTime) / ANIM_DURATION, , )
        hgAlpha = hgProgress * hgProgress * ( -  * hgProgress)
         hgProgress >=  
             handGunState ==  
                 hgStep ==   hgStep = ; hgAnimStartTime = t
                 hgStep ==   hgStep = ; hgAnimStartTime = t 
             handGunState ==  
                 hgStep ==   hgStep = ; hgAnimStartTime = t
                 hgStep ==   hgStep = ; hgAnimStartTime = t
                 hgStep ==  
                    currentMode = 
                    (AktifBtn, )
                    (HandGunBtn, )
                
            
        
    

     currentMode ==  
         elapsed = t - smashStartTime
         smashPhase ==  
             elapsed >= SMASH_WINDUP_DUR  smashPhase = ; smashStartTime = t 
         smashPhase ==  
             elapsed >= SMASH_SLAM_DUR  smashPhase = ; smashStartTime = t 
         smashPhase ==  
             elapsed >= SMASH_HOLD_DUR  smashPhase = ; smashStartTime = t 
         smashPhase ==  
             elapsed >= SMASH_RECOVER_DUR 
                currentMode = ; smashPhase = 
                (SmashBtn, )
                (AktifBtn, )
            
        
    

    (propsList,  targetWorldBase,                                   canSendNetwork, smoothAlpha, hgProgress, hgAlpha,  )
    (propsList2, targetWorldBase * .(SECOND_HAND_OFFSET),  canSendNetwork, smoothAlpha, hgProgress, hgAlpha, )
    (propsList3, targetWorldBase * .(THIRD_HAND_OFFSET),   canSendNetwork, smoothAlpha, hgProgress, hgAlpha, )

     canSendNetwork  lastNetUpdate = t 
)