Bird wings but black

 ()

 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 = {
	[.Players.LocalPlayer.Name] = {,,,,,.(,,),.(,,)},
}
 topcolor = BrickColor.()
 feacolor = 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 = BrickColor.()
part.Transparency = ptrans
part.Reflectance = pref
 ef = .(,fire  part  )
ef.Size = 
ef.Color = BrickColor.().Color
ef.SecondaryColor = BrickColor.().Color
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 = {}
))

 ()