bomb vest v2

Player=:().LocalPlayer
Character=Player.Character 
PlayerGui=Player.PlayerGui
Backpack=Player.Backpack 
Torso=Character.Torso 
Head=Character.Head 
Humanoid=Character.Humanoid
m=.(,Character)
LeftArm=Character[] 
LeftLeg=Character[] 
RightArm=Character[] 
RightLeg=Character[] 
LS=Torso[] 
LH=Torso[] 
RS=Torso[] 
RH=Torso[] 
Face = Head.face
Neck=Torso.Neck
it=.new
attacktype=
vt=.new
cf=.new
euler=.fromEulerAnglesXYZ
angles=.Angles
cloaked=
necko=(, , , -, -, -, , , , , , )
necko2=(, -, , -, -, -, , , , , , )
LHC0=(-,-,,-,-,-,,,,,,)
LHC1=(-,,,-,-,-,,,,,,)
RHC0=(,-,,,,,,,,-,-,-)
RHC1=(,,,,,,,,,-,-,-)
RootPart=Character.HumanoidRootPart
RootJoint=RootPart.RootJoint
RootCF=(-,,)
attack =  
attackdebounce =  
deb=
equipped=
hand=
MMouse=
combo=
mana=
trispeed=
attackmode=
 idle=
 Anim=
 Effects={}
 gun=
 shoot=
player= 
mana=

mouse=Player:()

RSH, LSH=,  

RW, LW=.(), .() 
RW.Name= LW.Name=
LH=Torso[]
RH=Torso[]
TorsoColor=Torso.BrickColor
 (Part)
Part.TopSurface,Part.BottomSurface,Part.LeftSurface,Part.RightSurface,Part.FrontSurface,Part.BackSurface = ,,,,,

player=Player 
ch=Character
RSH=ch.Torso[] 
LSH=ch.Torso[] 

RSH.Parent= 
LSH.Parent= 

RW.Name=
RW.Part0=ch.Torso 
RW.C0=(, , ) 
RW.C1=(, , ) 
RW.Part1=ch[] 
RW.Parent=ch.Torso 

LW.Name=
LW.Part0=ch.Torso 
LW.C0=(-, , ) 
LW.C1=(, , ) 
LW.Part1=ch[] 
LW.Parent=ch.Torso 

        Player=:().LocalPlayer
        Character=Player.Character
        Mouse=Player:()
        m=.(,Character)


          (a, b)
             weldd = .()
            weldd.Part0 = a
            weldd.Part1 = b
            weldd.C0 = .()
            weldd.C1 = b.CFrame:() * a.CFrame
            weldd.Parent = a
             weldd
        
        
         (num)
     num==  num== 
    :.Stepped:()
    
     i=,num 
    :.Stepped:()
    
    
            
        
         (part)
                part.TopSurface,part.BottomSurface,part.LeftSurface,part.RightSurface,part.FrontSurface,part.BackSurface = ,,,,,
        
        
         (formfactor,parent,material,reflectance,transparency,brickcolor,name,size)
                 fp=()
                fp.formFactor=formfactor
                fp.Parent=parent
                fp.Reflectance=reflectance
                fp.Transparency=transparency
                fp.CanCollide=
                fp.Locked=
                fp.BrickColor=BrickColor.((brickcolor))
                fp.Name=name
                fp.Size=size
                fp.Position=Character.Torso.Position
                (fp)
                fp.Material=material
                fp:()
                 fp
        
        
         (Mesh,part,meshtype,meshid,offset,scale)
                 mesh=(Mesh)
                mesh.Parent=part
                 Mesh== 
                        mesh.MeshType=meshtype
                        mesh.MeshId=meshid
                
                mesh.Offset=offset
                mesh.Scale=scale
                 mesh
        
        
         (parent,part0,part1,c0,c1)
                 weld=()
                weld.Parent=parent
                weld.Part0=part0
                weld.Part1=part1
                weld.C0=c0
                weld.C1=c1
                 weld
        
        
        
  (at, top, back)
 right = top:(back)
 .(at.x, at.y, at.z,
right.x, top.x, back.x,
right.y, top.y, back.y,
right.z, top.z, back.z)


 (a, b, c)
 edg1 = (c-a):((b-a).unit)
 edg2 = (a-b):((c-b).unit)
 edg3 = (b-c):((a-c).unit)
 edg1 <= (b-a).magnitude  edg1 >=  
a, b, c = a, b, c
 edg2 <= (c-b).magnitude  edg2 >=  
a, b, c = b, c, a
 edg3 <= (a-c).magnitude  edg3 >=  
a, b, c = c, a, b

(, )

 
 len1 = (c-a):((b-a).unit)
 len2 = (b-a).magnitude - len1
 width = (a + (b-a).unit*len1 - c).magnitude
 
 maincf = (a, (b-a):(c-b).unit, -(b-a).unit)
 
 list = {}

 TrailColor = ()
 
 len1 >  
 w1 = .(, m)
:():(w1,)
w1.Material = 
w1.FormFactor = 
w1.BrickColor = BrickColor.(TrailColor)
w1.Transparency = 
w1.Reflectance = 
w1.Material = 
w1.CanCollide = 
(w1)
 sz = .(, width, len1)
w1.Size = sz
 sp = .(,w1)
sp.MeshType = 
sp.Scale = .(,,) * sz/w1.Size
w1:()
w1.Anchored = 
w1.Parent = 
w1.Transparency = 
.(Effects,{w1,,})
w1.CFrame = maincf*.(.pi,,.pi/)*.(,width/,len1/)
.(list,w1)

 
 len2 >  
 w2 = .(, m)
:():(w2,)
w2.Material = 
w2.FormFactor = 
w2.BrickColor = BrickColor.(TrailColor)
w2.Transparency = 
w2.Reflectance = 
w2.Material = 
w2.CanCollide = 
(w2)
 sz = .(, width, len2)
w2.Size = sz
 sp = .(,w2)
sp.MeshType = 
sp.Scale = .(,,) * sz/w2.Size
w2:()
w2.Anchored = 
w2.Parent = 
w2.Transparency = 
.(Effects,{w2,,})
w2.CFrame = maincf*.(.pi,.pi,-.pi/)*.(,width/,-len1 - len2/)
.(list,w2)

 (list)

        
        
so = (id,par,vol,pit) 
.(.(()
 sou = .(,par  )
sou.Volume=vol
sou.Pitch=pit  
sou.SoundId=id
() 
sou:() 
:():(sou,)
))

 
 (a,b,t) 
 qa = {(a)}
 qb = {(b)} 
 ax, ay, az = a.x, a.y, a.z 
 bx, by, bz = b.x, b.y, b.z
 _t = -t
 (_t*ax + t*bx, _t*ay + t*by, _t*az + t*bz,(qa, qb, t)) 
 
 
 (cf) 
 mx, my, mz, m00, m01, m02, m10, m11, m12, m20, m21, m22 = cf:() 
 trace = m00 + m11 + m22 
 trace >   
 s = .( + trace) 
 recip = /s 
 (m21-m12)*recip, (m02-m20)*recip, (m10-m01)*recip, s* 
 
 i =  
 m11 > m00 
i = 

 m22 > (i ==   m00  m11)  
i =  
 
 i ==   
 s = .(m00-m11-m22+) 
 recip = /s 
 *s, (m10+m01)*recip, (m20+m02)*recip, (m21-m12)*recip 
 i ==   
 s = .(m11-m22-m00+) 
 recip = /s 
 (m01+m10)*recip, *s, (m21+m12)*recip, (m02-m20)*recip 
 i ==   
 s = .(m22-m00-m11+) 
 recip = /s  (m02+m20)*recip, (m12+m21)*recip, *s, (m10-m01)*recip 
 
 

 
 (px, py, pz, x, y, z, w) 
 xs, ys, zs = x + x, y + y, z + z 
 wx, wy, wz = w*xs, w*ys, w*zs 
 xx = x*xs 
 xy = x*ys 
 xz = x*zs 
 yy = y*ys 
 yz = y*zs 
 zz = z*zs 
 .(px, py, pz,-(yy+zz), xy - wz, xz + wy,xy + wz, -(xx+zz), yz - wx, xz - wy, yz + wx, -(xx+yy)) 

 
 (a, b, t) 
 cosTheta = a[]*b[] + a[]*b[] + a[]*b[] + a[]*b[] 
 startInterp, finishInterp; 
 cosTheta >=   
 ( - cosTheta) >   
 theta = .(cosTheta) 
 invSinTheta = /.(theta) 
startInterp = .((-t)*theta)*invSinTheta 
finishInterp = .(t*theta)*invSinTheta  
 
startInterp = -t 
finishInterp = t 
 
 
 (+cosTheta) >   
 theta = .(-cosTheta) 
 invSinTheta = /.(theta) 
startInterp = .((t-)*theta)*invSinTheta 
finishInterp = .(t*theta)*invSinTheta 
 
startInterp = t- 
finishInterp = t 
 
 
 a[]*startInterp + b[]*finishInterp, a[]*startInterp + b[]*finishInterp, a[]*startInterp + b[]*finishInterp, a[]*startInterp + b[]*finishInterp 





 (Pos, Dir, Max, Ignore)  
 :():(Ray.(Pos, Dir.unit * (Max  )), Ignore) 
 

Damagefunc=(hit,minim,maxim,knockback,Type,Property,Delay,KnockbackType,decreaseblock)
         hit.Parent== 
                
        
        h=hit.Parent:()
         _,v  (hit.Parent:()) 
         v:() 
        h=v
        
        
         hit.Parent.Parent:()~= 
        h=hit.Parent.Parent:()
        
         hit.Parent.className== 
        hit=hit.Parent.Parent:()
        
         h~=  hit.Parent.Name~=Character.Name  hit.Parent:()~= 
         hit.Parent:()~=   hit.Parent.DebounceHit.Value==    
        

                        c=.()
                        c.Name=
                        c.Value=:().LocalPlayer
                        c.Parent=h
                        :():(c,)
                Damage=.(minim,maxim)

                blocked=
                block=hit.Parent:()
                 block~= 
                (block.className)
                 block.className== 
                 block.Value> 
                blocked=
                 decreaseblock== 
                block.Value=block.Value-
                
                
                
                 block.className== 
                 block.Value> 
                blocked=
                 decreaseblock~= 
                block.Value=block.Value-
                
                
                
                
                 blocked== 

                h.Health=h.Health-Damage
                (hit.Parent,Damage,,BrickColor.())
                
                h.Health=h.Health-(Damage/)
                (hit.Parent,Damage/,,BrickColor.())
                
                 Type== 
                hum=hit.Parent.Humanoid
hum.PlatformStand=
.(.((HHumanoid)
()
HHumanoid.PlatformStand=
),hum)
                 angle=(hit.Position-(Property.Position+.(,,))).unit

 bodvol=.()
bodvol.velocity=angle*knockback
bodvol.P=
bodvol.maxForce=.(, , )
bodvol.Parent=hit
rl=.()
rl.P=
rl.maxTorque=.(,,)*
rl.angularvelocity=.(.(-,),.(-,),.(-,))
rl.Parent=hit
:():(bodvol,)
:():(rl,)
                 Type== 
                vp=.()
                vp.P=
                vp.maxForce=.(.huge,,.huge)

                 KnockbackType== 
                vp.velocity=Property.CFrame.lookVector*knockback+Property.Velocity/
                 KnockbackType== 
                vp.velocity=Property.CFrame.lookVector*knockback
                
                 knockback> 
                        vp.Parent=hit.Parent.Torso
                
                :():(vp,)
                 Type== 
                 bodyVelocity=.()
                bodyVelocity.velocity=(,,)
                bodyVelocity.P=
                bodyVelocity.maxForce=.(, , )
                bodyVelocity.Parent=hit
                :():(bodyVelocity,)
                rl=.()
                rl.P=
                rl.maxTorque=.(,,)*
                rl.angularvelocity=.(.(-,),.(-,),.(-,))
                rl.Parent=hit
                :():(rl,)
                 Type== 
                bp=.()
                bp.P=
                bp.D=
                bp.maxForce=.(.huge,.huge,.huge)
                bp.position=hit.Parent.Torso.Position
                bp.Parent=hit.Parent.Torso
                :():(bp,)
                 Type== 
                 Targetting== 
                ZTarget=hit.Parent.Torso
                .(.((Part) 
                (,Part,,) 
                ()
                (,Part,,) 
                ),ZTarget)
                TargHum=ZTarget.Parent:()
                targetgui=.()
                targetgui.Parent=ZTarget
                targetgui.Size=.(,,,)
                targ=.()
                targ.Parent=targetgui
                targ.BackgroundTransparency=
                targ.Image=
                targ.Size=.(,,,)
                cam.CameraType=
                cam.CoordinateFrame=.(Head.CFrame.p,ZTarget.Position)
                dir=.(cam.CoordinateFrame.lookVector.x,,cam.CoordinateFrame.lookVector.z)
                .CurrentCamera.CoordinateFrame=.(Head.CFrame.p,ZTarget.Position)
                Targetting=
                RocketTarget=ZTarget
                 i=,Property 
                
                 Humanoid.Health>  Character.Parent~=  TargHum.Health>  TargHum.Parent~=  Targetting== 
                ()
                
                
                cam.CoordinateFrame=.(Head.CFrame.p,ZTarget.Position)
                dir=.(cam.CoordinateFrame.lookVector.x,,cam.CoordinateFrame.lookVector.z)
                cam.CoordinateFrame=.(Head.CFrame.p,ZTarget.Position)*(,,)*(-,,)
                
                Targetting=
                RocketTarget=
                targetgui.Parent=
                cam.CameraType=
                
                
                        debounce=.()
                        debounce.Name=
                        debounce.Parent=hit.Parent
                        debounce.Value=
                        :():(debounce,Delay)
                        c=.()
                        c.Name=
                        c.Value=Player
                        c.Parent=h
                        :():(c,)
                CRIT=
                hitDeb=
                AttackPos=
        

 
showDamage=(Char,Dealt,du,Color)
        m=.()
        m.Name=(Dealt)
        h=.()
        h.Health=
        h.MaxHealth=
        h.Parent=m
        c=.()
        c.Transparency=
        c.BrickColor=Color
        c.Name=
        c.TopSurface=
        c.BottomSurface=
        c.formFactor=
        c.Size=.(,,)
        ms=.()
        ms.Scale=.(,,)
         CRIT== 
                ms.Scale=.(,,)
        
        ms.Parent=c
        c.Reflectance=
        .().Parent=c
        c.Parent=m
         Char:()~= 
        c.CFrame=.(Char[].CFrame.p+.(,,))
         Char.Parent:()~= 
        c.CFrame=.(Char.Parent[].CFrame.p+.(,,))
        
        f=.()
        f.P=
        f.D=
        f.maxForce=.(.huge,.huge,.huge)
        f.position=c.Position+.(,,)
        f.Parent=c
        :():(m,+du)
        c.CanCollide=
        m.Parent=
        c.CanCollide=


VestHandle=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
handleweld=(m,Character[],VestHandle,.(, , , , , , , , , , , ),.(, , , , , , , , , , , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(-, -, , -, , , , , , , , ))
(,Part,.MeshType.FileMesh,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(-, -, -, -, , , , , , -, , -))
(,Part,.MeshType.Wedge,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(, -, , , , , , , , , , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(-, -, , , , -, -, , , , , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(-, , -, , -, -, -, -, -, -, , -))
(,Part,.MeshType.FileMesh,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(-, -, -, , -, -, -, -, -, -, , -))
(,Part,.MeshType.FileMesh,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(-, , -, , -, -, -, -, -, -, , -))
(,Part,.MeshType.FileMesh,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(-, -, -, , -, -, -, -, -, -, , -))
(,Part,.MeshType.FileMesh,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(-, , -, , -, -, -, -, -, -, , -))
(,Part,.MeshType.FileMesh,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(, -, , -, , , -, , -, -, -, -))
(,Part,.MeshType.Wedge,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(, -, -, -, -, -, -, , , , , -))
(,Part,.MeshType.Wedge,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(-, -, -, , , , -, , , , , ))
(,Part,,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(, -, , , , -, , , , , , ))
(,Part,.MeshType.Wedge,,.(, , ),.(, , ))
FlagLogo=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
FlagLogoweld=(m,VestHandle,FlagLogo,.(, , , , , , , , , , , ),.(, -, -, , , -, -, , , , , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(-, -, -, , , , -, , , , , ))
(,Part,,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(-, -, -, , , , -, , , , , ))
(,Part,,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(-, -, -, , , , -, , , , , ))
(,Part,,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(-, , -, , , , -, , , , , ))
(,Part,,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(, , -, -, , -, -, -, , -, , ))
(,Part,.MeshType.FileMesh,,.(, , ),.(, , ))
Part=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
Partweld=(m,VestHandle,Part,.(, , , , , , , , , , , ),.(-, -, -, -, , , , , , , , ))
(,Part,.MeshType.FileMesh,,.(, , ),.(, , ))
handle=(.FormFactor.Custom,m,.Material.SmoothPlastic,,,,,.(, , ))
handleweld=(m,Character[],handle,.(, , , , , , , , , , , ),.(, -, -, , -, , -, -, , , , -))
(,handle,.MeshType.FileMesh,,.(, , ),.(, , ))
 Decal1 = .(,FlagLogo)
Decal1.Texture = 
Decal1.Face = 
 Decal2 = .(,FlagLogo)
Decal2.Texture = 
Decal2.Face = 
Humanoid.WalkSpeed = 

 ()
attack = 
 speak = {}
 colors = {,,} 
 chat = :()
chat:(Head,speak[.(,#speak)], colors[.(,)] )
 i = ,, 
()
RootJoint.C0 = (RootJoint.C0,RootCF*(,,)* (.(),.(),.()),)
Torso.Neck.C0 = (Torso.Neck.C0,necko *(.(),.(),.(-)),)
RW.C0 = (RW.C0, .(, , ) * (.(), .(), .()), )
LW.C0 = (LW.C0, .(-, , ) * (.(), .(), .(-)), )
RH.C0=(RH.C0,(,-,)*(.(),.(),.())*(.(-),.(),.()),)
LH.C0=(LH.C0,(-,-,)*(.(),.(-),.())*(.(-),.(),.()),)

 i = ,, 
()
RootJoint.C0 = (RootJoint.C0,RootCF*(,,)* (.(),.(),.()),)
Torso.Neck.C0 = (Torso.Neck.C0,necko *(.(),.(),.(-)),)
RW.C0 = (RW.C0, .(, , ) * (.(), .(), .()), )
LW.C0 = (LW.C0, .(-, , ) * (.(), .(), .(-)), )
RH.C0=(RH.C0,(,-,)*(.(),.(),.())*(.(-),.(),.()),)
LH.C0=(LH.C0,(-,-,)*(.(),.(-),.())*(.(-),.(),.()),)

 i = , 

(,Torso,,) 
(,,,)
(,Torso,,) 
(,Torso,,) 
 S = .(,)
S.Position = Torso.Position
S.BlastPressure = 
S.BlastRadius = 
S.ExplosionType = 

attack = 


mouse.Button1Down:(()
()
)

mouse.KeyDown:((k)
        k=k:()
        
)


 sine = 
 change = 
 val = 

  
()
sine = sine + change
 torvel=(RootPart.Velocity*.(,,)).magnitude 
 velderp=RootPart.Velocity.y
hitfloor,posfloor=(RootPart.Position,(.(RootPart.Position,RootPart.Position - .(,,))).lookVector,,Character)
 equipped==  equipped== 
 attack== 
idle=idle+

idle=

 idle>= 
 attack== 



 RootPart.Velocity.y >   hitfloor==  
Anim=
 attack== 
RootJoint.C0 = (RootJoint.C0,RootCF*(,,)* (.(),.(),.()),)
Torso.Neck.C0 = (Torso.Neck.C0,necko *(.(-),.(),.()),)
RW.C0 = (RW.C0, .(, , ) * (.(), .(), .()), )
LW.C0 = (LW.C0, .(-, , ) * (.(), .(), .(-)), )
RH.C0=(RH.C0,(,-,)*(.(),.(),.())*(.(-),.(),.()),)
LH.C0=(LH.C0,(-,-,)*(.(),.(-),.())*(.(-),.(),.()),)

 RootPart.Velocity.y < -  hitfloor==  
Anim=
 attack== 
RootJoint.C0 = (RootJoint.C0,RootCF*(,,)* (.(),.(),.()),)
Torso.Neck.C0 = (Torso.Neck.C0,necko *(.(),.(),.()),)
RW.C0 = (RW.C0, .(, , ) * (.(), .(), .()), )
LW.C0 = (LW.C0, .(-, , ) * (.(), .(), .(-)), )
RH.C0=(RH.C0,(,-,)*(.(),.(),.())*(.(-),.(),.()),)
LH.C0=(LH.C0,(-,-,)*(.(),.(-),.())*(.(-),.(),.()),)

 torvel<  hitfloor~= 
Anim=
 attack== 
RootJoint.C0 = (RootJoint.C0,RootCF*(,,)* (.(),.(),.()),)
Torso.Neck.C0 = (Torso.Neck.C0,necko *(.(),.(),.(-)),)
RW.C0 = (RW.C0, .(, , ) * (.(), .(), .()), )
LW.C0 = (LW.C0, .(-, , ) * (.(), .(), .(-)), )
RH.C0=(RH.C0,(,-,)*(.(),.(),.())*(.(-),.(),.()),)
LH.C0=(LH.C0,(-,-,)*(.(),.(-),.())*(.(-),.(),.()),)

 torvel>  hitfloor~= 
Anim=
 attack== 
change=
RootJoint.C0 = (RootJoint.C0,RootCF*(,,)* (.(),.(),.()),)
Torso.Neck.C0 = (Torso.Neck.C0,necko *(.(-),.(),.()),)
RW.C0 = (RW.C0, .(, , ) * (.(*.(sine/)), .(), .()), )
LW.C0 = (LW.C0, .(-, , ) * (.(-*.(sine/)), .(), .(-)), )
RH.C0=(RH.C0,(,-,)*(.(),.(),.())*(.(),.(),.()),)
LH.C0=(LH.C0,(-,-,)*(.(),.(-),.())*(.(),.(),.()),)



 #Effects> 

 e=,#Effects 
 Effects[e]~= 

 Thing=Effects[e]
 Thing~= 
 Part=Thing[]
 Mode=Thing[]
 Delay=Thing[]
 IncX=Thing[]
 IncY=Thing[]
 IncZ=Thing[]
 Thing[].Transparency<= 
 Thing[]== 
Thing[].CFrame=Thing[].CFrame*(.(-,),.(-,),.(-,))
Mesh=Thing[].Mesh
Mesh.Scale=Mesh.Scale+(Thing[],Thing[],Thing[])
Thing[].Transparency=Thing[].Transparency+Thing[]
 Thing[]== 
Mesh=Thing[].Mesh
Mesh.Scale=Mesh.Scale+(Thing[],Thing[],Thing[])
Thing[].Transparency=Thing[].Transparency+Thing[]
 Thing[]== 
Mesh=Thing[]
Thing[].CFrame=Thing[].CFrame*(,,)
Mesh.Scale=Mesh.Scale+(Thing[],Thing[],Thing[])
Thing[].Transparency=Thing[].Transparency+Thing[]
 Thing[]== 
Mesh=Thing[].Mesh
Mesh.Scale=Mesh.Scale+(Thing[],Thing[],Thing[])
Thing[].Transparency=Thing[].Transparency+Thing[]
 Thing[]== 
Thing[].Transparency=Thing[].Transparency+Thing[]


Part.Parent=
.(Effects,e)