Cool wings

 





.Parent = 

 ()

 i,v  (:()) 

        (() v.Value =  )

        :():(v,)



 (p0,p1,c0,c1,par)

         w = .(,p0  par)

        w.Part0 = p0

        w.Part1 = p1

        w.C0 = c0  .()

        w.C1 = c1  .()

         w



 motors = {}

 (p0,p1,c0,c1,des,vel,par)

         w = .(,p0  par)

        w.Part0 = p0

        w.Part1 = p1

        w.C0 = c0  .()

        w.C1 = c1  .()

        w.MaxVelocity = (vel)  

        w.DesiredAngle = (des)  

         w



 (a,b,c)

     a+(b-a)*c



 (c1,c2,al)

         com1 = {c1.X,c1.Y,c1.Z,c1:()}

         com2 = {c2.X,c2.Y,c2.Z,c2:()}

         i,v  (com1) 

                com1[i] = (v,com2[i],al)

        

         .(com1[],com1[],com1[]) * .((,(com1)))



 (c1,c2,al)

         com1 = {c1:()}

         com2 = {c2:()}

         i,v  (com1) 

                com1[i] = (v,com2[i],al)

        

         .((com1))



 (time,length,offset)

         (.((()+(offset  ))%time-time/)*-time/)/time/*length



 (c)

        c = c.Color

         BrickColor.(.(-c.b,-c.g,-c.r))



 oc = oc  (...)  ... 

 plr = .Players.LocalPlayer

 char = plr.Character

 tor = char.Torso

 hum = char.Humanoid

hum.PlatformStand = 

(()

        char.Wings:()

)

(()

        char.Angel:() 

)

 mod = .(,char)

mod.Name = 

 special = {

        

        antiboomz0r = {,,,,,.(,,),.(,,)},

        

        taart = {,,,,},

        mitta = {,,,,},

        penjuin3 = {,,,,},

        thepc8110 = {,,,,,.(,,),.(,,)},

        nonspeaker = {,,,,,.(,,),.(,,)},

        littleau999 = {,,,,},

        unscripter = {,,,,,.(,,),.(,,)},

        oxcool1 = {,,,,,.(,,),.(,,)},

        krodmiss = {,,,,},

}

 topcolor = (char.Torso.BrickColor)

 feacolor = char.Torso.BrickColor

 ptrans = 

 pref = 

 fire = 

 fmcol = .()

 fscol = .()

 spec = special[plr.Name:()]

 spec 

        topcolor,feacolor,ptrans,pref,fire,fmcol,fscol = spec[]  BrickColor.(spec[])  topcolor,spec[]  BrickColor.(spec[])  feacolor,spec[],spec[],spec[],spec[],spec[]



 part = .()

part.FormFactor = 

part.Size = .(,,)

part.TopSurface,part.BottomSurface = ,

part.CanCollide = 

part.BrickColor = topcolor

part.Transparency = ptrans

part.Reflectance = pref

 ef = .(,fire  part  )

ef.Size = 

ef.Color = fmcol  .()

ef.SecondaryColor = fscol  .()

part:()


 ()

         clone = part:()

        clone.Parent = mod

        clone:()

         clone



 feath = ()

feath.BrickColor = feacolor

feath.Transparency = 

.(,feath).MeshType = 

 ()

         clone = feath:()

        clone.Parent = mod

        clone:()

         clone






 r1 = ()

r1.Size = .(,,)*

 rm1 = (tor,r1,.(,,) * .(,,.(-)) * .(.(),.(-),),.(,-,),)

 r2 = ()

r2.Size = .(,,)*

 rm2 = (r1,r2,.(,,) * .(,,.()) * .(.(-),.(),),.(,-,),)

 r3 = ()

r3.Size = .(,,)*

 rm3 = (r2,r3,.(,,) * .(,,.(-)) * .(.(-),,),.(,-,),)

 r4 = ()

r4.Size = .(,,)*

 rm4 = (r3,r4,.(,,) * .(,,.(-)) * .(.(-),,),.(,-,),)

 feather = ()

feather.Mesh.Scale = .(,,)

feather.Size = .(,,)

(r4,feather,.(-,-,),.(,-,))

feather = ()

feather.Mesh.Scale = .(,,)

feather.Size = .(,,)

(r4,feather,.(,-,) * .(,.()*,),.(,-,))

feather = ()

feather.Mesh.Scale = .(,,)

feather.Size = .(,,)

(r4,feather,.(,-,) * .(,.()*,.(-)),.(,-,))

 rf3 = {}

 i=, 

        feather = ()

        feather.Mesh.Scale = .(,,)

        feather.Size = .(,,)

        .(rf3,(r3,feather,.(,-i*,) * .(,.()*,.(--i*)),.(,-feather.Size.Y/,)))



 rf2 = {}

 i=, 

        feather = ()

        feather.Mesh.Scale = .(,,)

        feather.Size = .(,-i*,)

        .(rf2,(r2,feather,.(,-i*,) * .(,.()*,.(--i*)),.(,-feather.Size.Y/,)))



 rf1 = {}

 i=, 

        feather = ()

        feather.Mesh.Scale = .(,,)

        feather.Size = .(,-i*,)

        .(rf1,(r1,feather,.(,-i*,) * .(,.()*,.(-)),.(,-feather.Size.Y/,)))





 l1 = ()

l1.Size = .(,,)*

 lm1 = (tor,l1,.(-,,) * .(,,.()) * .(.(),.(),) * .(,-.pi,),.(,-,) ,)

 l2 = ()

l2.Size = .(,,)*

 lm2 = (l1,l2,.(,,) * .(,,.()) * .(.(),.(-),),.(,-,),)

 l3 = ()

l3.Size = .(,,)*

 lm3 = (l2,l3,.(,,) * .(,,.(-)) * .(.(),,),.(,-,),)

 l4 = ()

l4.Size = .(,,)*

 lm4 = (l3,l4,.(,,) * .(,,.(-)) * .(.(),,),.(,-,),)

 feather = ()

feather.Mesh.Scale = .(,,)

feather.Size = .(,,)

(l4,feather,.(-,-,),.(,-,))

feather = ()

feather.Mesh.Scale = .(,,)

feather.Size = .(,,)

(l4,feather,.(,-,) * .(,.()*,),.(,-,))

feather = ()

feather.Mesh.Scale = .(,,)

feather.Size = .(,,)

(l4,feather,.(,-,) * .(,.()*,.(-)),.(,-,))

 lf3 = {}

 i=, 

        feather = ()

        feather.Mesh.Scale = .(,,)

        feather.Size = .(,,)

        .(lf3,(l3,feather,.(,-i*,) * .(,.()*,.(--i*)),.(,-feather.Size.Y/,)))



 lf2 = {}

 i=, 

        feather = ()

        feather.Mesh.Scale = .(,,)

        feather.Size = .(,-i*,)

        .(lf2,(l2,feather,.(,-i*,) * .(,.()*,.(--i*)),.(,-feather.Size.Y/,)))



 lf1 = {}

 i=, 

        feather = ()

        feather.Mesh.Scale = .(,,)

        feather.Size = .(,-i*,)

        .(lf1,(l1,feather,.(,-i*,) * .(,.()*,.(-)),.(,-feather.Size.Y/,)))



 rwing = {rm1,rm2,rm3,rm4}

 lwing = {lm1,lm2,lm3,lm4}

 oc0 = {}

 i,v  (rwing) 

        oc0[v] = v.C0



 i,v  (lwing) 

        oc0[v] = v.C0



 ()

         lastsize 

                 tor.Size == lastsize    

                 scaleVec = tor.Size/lastsize

                 i,v  (oc0) 

                        oc0[i] = v-v.p+scaleVec*v.p

                

                lastsize = tor.Size

        

        lastsize = tor.Size



tor.Changed:((p)

         p ==  

                ()

        

)

()

 idle = {,,-,; ,,,; -,-,,;}

 outlow = {-,-,,; ,,,; ,,,}

 outhigh = {,-,,; ,,,; ,,,}

 veryhigh = {,-,,; ,,,; ,,,}

 flap1 = {-,,,-; ,,,; ,-,,}

 divebomb = {,,,-; ,,,; ,-,-,}


 (tab,time)

        time = time  

         i=, 

                rwing[i].DesiredAngle = tab[i]

                lwing[i].DesiredAngle = tab[i]

                rwing[i].MaxVelocity = .(tab[i]-rwing[i].CurrentAngle)/time

                lwing[i].MaxVelocity = .(tab[i]-lwing[i].CurrentAngle)/time

                 rcf = oc0[rwing[i]] * (tab[+i]  .())

                 lcf = oc0[lwing[i]] * (tab[+i]  .())

        

         i,v  (rf1) 

                v.DesiredAngle = tab[]

                v.MaxVelocity = .(v.DesiredAngle-v.CurrentAngle)/time

        

         i,v  (lf1) 

                v.DesiredAngle = tab[]

                v.MaxVelocity = .(v.DesiredAngle-v.CurrentAngle)/time

        

         i,v  (rf2) 

                v.DesiredAngle = tab[]

                v.MaxVelocity = .(v.DesiredAngle-v.CurrentAngle)/time

        

         i,v  (lf2) 

                v.DesiredAngle = tab[]

                v.MaxVelocity = .(v.DesiredAngle-v.CurrentAngle)/time

        

         i,v  (rf3) 

                v.DesiredAngle = tab[]

                v.MaxVelocity = .(v.DesiredAngle-v.CurrentAngle)/time

        

         i,v  (lf3) 

                v.DesiredAngle = tab[]

                v.MaxVelocity = .(v.DesiredAngle-v.CurrentAngle)/time

        



(outhigh,)

flying = 

moving = 

 i,v  (tor:()) 

         v.ClassName:():() 

                v:()

        



 ctor = tor:()

ctor:()

ctor.Name = 

ctor.Transparency = 

ctor.CanCollide = 

ctor.FormFactor = 

ctor.Size = .(,,)

ctor.Parent = mod

(tor,ctor)

 bg = .(,ctor)

bg.maxTorque = .()

bg.P = 

bg.D = 

 bv = .(,ctor)

bv.maxForce = .()

bv.P = 

vel = .()

cf = .()

flspd = 


keysdown = {}

keypressed = {}

ktime = {}

descendtimer = 

jumptime = ()

hum.Jumping:(()

        jumptime = ()

)

cam = .CurrentCamera

kd = plr:().KeyDown:(((key) 

        keysdown[key] =  

        keypressed[key] =  

         key ==   

                descendtimer = () 

         key ==    hum.Jump  

                jumptime = ()

         (key ==   key == )  ktime[key]  ()-ktime[key] <   .(reqrotx) <  

                reqrotx = key ==   .pi*  -.pi*

        

        ktime[key] = () 

))

ku = plr:().KeyUp:((key) 

        keysdown[key] =  

         key ==   

                descendtimer = () 

         

)

 (a,b,c)

         .(a,.(b,c  -a))



 (a)

         a    



 (tar)

         m = 

         i,v  (tar:()) 

                 v:() 

                        m = m + v:()

                

                        m = m + (v)

        

         m



reqrotx = 

 grav = 

 con

con = :().Stepped:((()

        

         obvel = tor.CFrame:(tor.Velocity)

         sspd, uspd,fspd = obvel.X,obvel.Y,obvel.Z

         flying 

                 lfldir = fldir

                fldir = cam.CoordinateFrame:(.((keysdown.d)-(keysdown.a),,(keysdown.s)-(keysdown.w))).unit

                 lmoving = moving

                moving = fldir.magnitude > 

                 lmoving   moving 

                        idledir = lfldir*.(,,)

                        descendtimer = ()

                

                 dbomb = fldir.Y < -  (moving  keysdown[])

                 moving  keysdown[]  lmoving 

                        fldir = (.(lfldir.X,.(fldir.Y,lfldir.Y+)-,lfldir.Z)+(fldir*.(,,))*).unit

                

                 down = tor.CFrame:(.(,-,))

                 descending = ( moving  keysdown[]   keysdown[])

                cf = (cf,.(tor.Position,tor.Position+( moving  idledir  fldir)),keysdown[]    )

                 gdown =  dbomb  cf.lookVector.Y < -  tor.Velocity.unit.Y < 

                hum.PlatformStand = 

                bg.maxTorque = .(,,)*

                 rotvel = .(.(),tor.Velocity):(.(.(),fldir)).lookVector

                bg.cframe = cf * .( moving  -  -.pi/+,moving  (-,rotvel.X/) + reqrotx  ,)

                reqrotx = reqrotx - reqrotx/

                bv.maxForce = .(,,)**

                 anioff =((keysdown[])-(keysdown[]))/

                 ani = (-anioff,)

                bv.velocity = bv.velocity:(.(,( moving)*-ani*+(descending  .(,()-descendtimer)*-  (keysdown[])-(keysdown[]))*,)+vel,) 

                vel = moving  cf.lookVector*flspd  .()

                flspd = .(,(flspd,moving  (fldir.Y<  flspd+(-fldir.Y)*grav/  .(,flspd-fldir.Y*grav/))  ,))

                (moving  (gdown  outlow  dbomb  divebomb)  (descending  veryhigh  flap1),)

                 i=, 

                        

                        rwing[i].C0 = (rwing[i].C0,oc0[rwing[i]] * (gdown  .()  dbomb  .(-+(i==)*+(i==)*,+(i==)*-(i==)*,(i==)*)  descending  .(,,)  .((i*+)*ani,ani*-,*ani)),descending    )

                        lwing[i].C0 = (lwing[i].C0,oc0[lwing[i]] * (gdown  .()  dbomb  .(-(-+(i==)*+(i==)*),-(+(i==)*-(i==)*),(i==)*)  descending  .(-,,)  .(-(i*+)*ani,ani*,*ani)),descending    )

                

                 hit,ray = :(Ray.(tor.Position,.(,-+.(,bv.velocity.y)/,)),{char})

                 hit  down.Y < -  ()-flystart >  

                        flying = 

                        hum.PlatformStand = 

                        tor.Velocity = .()

                

        

                bg.maxTorque = .()

                bv.maxForce = .()

                 ani = (walking    ,)

                (idle,)

                 x,y,z = fspd/,uspd/,sspd/

                 i=, 

                        rwing[i].C0 = (rwing[i].C0,oc0[rwing[i]] * .(ani* + -(-,x), + -(-,y) + (i==)*,ani* + -(-,z)),)

                        lwing[i].C0 = (lwing[i].C0,oc0[lwing[i]] * .(ani*- + (-,x), + (-,y) + -(i==)*,ani* + (-,z)),)

                

                 keypressed[]   flying  (()-jumptime >   (()-jumptime <   hum.Jump)) 

                        vel = .(,,)

                        bv.velocity = vel

                        idledir = cam.CoordinateFrame.lookVector*.(,,)

                        cf = tor.CFrame * .(-,,)

                        tor.CFrame = cf

                        bg.cframe = cf

                        flystart = ()

                        flying = 

                

        

        keypressed = {}

))



 ()