Wing Joint Setup Tool

 

This is a tool I made in Maya 2012 using python. I had made 3 wing setups like this before using 3 custom attributes and driven keyframes so I figured it was time to automate the process and save some time. The three attributes are adjustable in scale before the joints are created. The number denotes the degrees traveled by the pointer finger of the wing at the extremes of each attribute. All the other fingers scale up and down in relation to the pointer finger.

 

            
import maya.cmds as mc
T = True
F = False

#temporary shaders for the widgets
if not mc.objExists('rMat'):
    mc.shadingNode('lambert', n='rMat', asShader=T)
    mc.shadingNode('lambert', n='gMat', asShader=T)
    mc.shadingNode('lambert', n='bMat', asShader=T)
    mc.shadingNode('lambert', n='grayMat', asShader=T)

    mc.setAttr('rMat.color', 1, 0, 0, type='double3')
    mc.setAttr('gMat.color', 0, 1, 0, type='double3')
    mc.setAttr('bMat.color', 0, 0, 1, type='double3')
    mc.setAttr('grayMat.color', 0.5, 0.5, 0.5, type='double3')

#make gizmo chain
def makeGizmoChain(*args):
    #basic arrow shape
    mc.polyCylinder(name='gizmo01', sx=6, sy=3)
    mc.select('gizmo01.vtx[0:11]', r=T)
    mc.scale(0.5, 0.5, 0.5, r=T)
    mc.select('gizmo01.vtx[0:23]', r=T)
    mc.move(0, 0.5, 0, r=T, os=T, wd=T)
    mc.select('gizmo01.vtx[18:23]', r=T)
    mc.MergeToCenter()
    mc.move(0, 2.0, 0, r=T, os=T, wd=T)
    mc.select('gizmo01.vtx[6:11]', r=T)
    mc.move(0, 0.4, 0, r=T, os=T, wd=T)
    mc.select('gizmo01.vtx[6:18]', r=T)
    mc.move(0, 1.0, 0, r=T, os=T, wd=T)
    mc.polySoftEdge('gizmo01.e[18:35]', a=180, ch=T)
    mc.polySoftEdge('gizmo01.e[6:17]', a=0, ch=T)

    #make more of them
    mc.select('gizmo01', r=T)

    for i in xrange(0,2):
        if(i==0):
            mc.duplicate(rr=T)
            mc.rotate(0, 0, 90, r=T, eu=T)
    
        else:
            mc.select('gizmo01', r=T)
            mc.duplicate(rr=T)
            mc.rotate(90, 0, 0, r=T, eu=T)
    
    mc.select('gizmo01.vtx[6:18]', r=T)
    mc.move(0, 4.0, 0, r=T, os=T, wd=T)
    mc.polySphere(name='gizmo04', sh=3, sx=6, sy=6)
    mc.polySoftEdge('gizmo04.e[0:65]', a=180, ch=T)

    #color them
    mc.select('gizmo04', 'gizmo01', r=T)
    mc.hyperShade(a='rMat')
    mc.select('gizmo02', r=T)
    mc.hyperShade(a='gMat')
    mc.select('gizmo03', r=T)
    mc.hyperShade(a='bMat')

    #smoosh them together
    mc.polyUnite('gizmo01', 'gizmo02', 'gizmo03', 'gizmo04', n='gizmo')
    mc.rotate(0, 0, -90, os=T, r=T)
    mc.scale(0.15, 0.15, 0.15, r=T)
    mc.makeIdentity(a=T, t=1, r=1, s=1, n=2)
    firstGizmo = mc.duplicate(rr=T)
    mc.delete('gizmo', 'gizmo01', 'gizmo02', 'gizmo03', 'gizmo04')
    mc.polyCube(n='LWingUp', w=0.5, h=0.5, d=0.5)

    #make a chain of widgets with adjustable X rotation
    for i in xrange(1,21):
        if(i==1):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(7.0, 0.0, -1.5, r=T, os=T, wd=T)
        if(i==2):
            mc.select(firstGizmo)            
            mc.duplicate(rr=T)
            mc.move(12.0, 0.0, 0.0, r=T, os=T, wd=T)
        if(i==3):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(13.0, 0.0, 1.0, r=T, os=T, wd=T)
        if(i==4):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(13.0, 0.0, 2.0, r=T, os=T, wd=T)
        if(i==5):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(13.5, 0.0, 0.25, r=T, os=T, wd=T)
        if(i==6):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(17.0, 0.0, -1.5, r=T, os=T, wd=T)
        if(i==7):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(19.0, 0.0, -3.75, r=T, os=T, wd=T)
        if(i==8):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(21.0, 0.0, -6.25, r=T, os=T, wd=T)
        if(i==9):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(13.0, 0.0, 0.0, r=T, os=T, wd=T)
        if(i==10):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(15.5, 0.0, -3.0, r=T, os=T, wd=T)
        if(i==11):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(17.0, 0.0, -6.25, r=T, os=T, wd=T)
        if(i==12):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(18.0, 0.0, -9.0, r=T, os=T, wd=T)
        if(i==13):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(12.75, 0.0, -0.25, r=T, os=T, wd=T)
        if(i==14):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(13.5, 0.0, -4.0, r=T, os=T, wd=T)
        if(i==15):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(14.0, 0.0, -7.25, r=T, os=T, wd=T)
        if(i==16):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(14.25, 0.0, -10.25, r=T, os=T, wd=T)
        if(i==17):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(12.25, 0.0, -0.25, r=T, os=T, wd=T)
        if(i==18):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(11.5, 0.0, -4.0, r=T, os=T, wd=T)
        if(i==19):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(10.5, 0.0, -7.25, r=T, os=T, wd=T)
        if(i==20):
            mc.select(firstGizmo)
            mc.duplicate(rr=T)
            mc.move(9.25, 0.0, -10.0, r=T, os=T, wd=T)
        
    mc.select(firstGizmo)
    mc.move(2.0, 0.0, 0.0, r=T, os=T, wd=T)
    
    #movable wing     
    for i in xrange(1,5):
        mc.select('gizmo'+str(i+1), 'gizmo'+str(i))
        mc.aimConstraint(o=(0, 0, 0), w=1.0, aim=(1, 0 ,0), u=(0, 1, 0), wut='objectrotation', wuo='LWingUp', wu=(0, 1, 0))
        if(i==4):
            mc.select('gizmo'+str(i), 'gizmo'+str(i+1))
            mc.orientConstraint(o=(0, 0, 0), w=1)
    for i in xrange(6,9):
        mc.select('gizmo'+str(i+1), 'gizmo'+str(i))
        mc.aimConstraint(o=(0, 0, 0), w=1.0, aim=(1, 0 ,0), u=(0, 1, 0), wut='objectrotation', wuo='LWingUp', wu=(0, 1, 0))
        if(i==8):
            mc.select('gizmo'+str(i), 'gizmo'+str(i+1))
            mc.orientConstraint(o=(0, 0, 0), w=1)
    for i in xrange(10,13):
        mc.select('gizmo'+str(i+1), 'gizmo'+str(i))
        mc.aimConstraint(o=(0, 0, 0), w=1.0, aim=(1, 0 ,0), u=(0, 1, 0), wut='objectrotation', wuo='LWingUp', wu=(0, 1, 0))
        if(i==12):
            mc.select('gizmo'+str(i), 'gizmo'+str(i+1))
            mc.orientConstraint(o=(0, 0, 0), w=1)
    for i in xrange(14,17):
        mc.select('gizmo'+str(i+1), 'gizmo'+str(i))
        mc.aimConstraint(o=(0, 0, 0), w=1.0, aim=(1, 0 ,0), u=(0, 1, 0), wut='objectrotation', wuo='LWingUp', wu=(0, 1, 0))
        if(i==16):
            mc.select('gizmo'+str(i), 'gizmo'+str(i+1))
            mc.orientConstraint(o=(0, 0, 0), w=1)
    for i in xrange(18,21):
        mc.select('gizmo'+str(i+1), 'gizmo'+str(i))
        mc.aimConstraint(o=(0, 0, 0), w=1.0, aim=(1, 0 ,0), u=(0, 1, 0), wut='objectrotation', wuo='LWingUp', wu=(0, 1, 0))
        if(i==20):
            mc.select('gizmo'+str(i), 'gizmo'+str(i+1))
            mc.orientConstraint(o=(0, 0, 0), w=1)
    rootGizmoPos = []
    gizmoPosL = mc.xform('gizmo1', q=T, ws=T, t=T)
    rootGizmoPos.append([gizmoPosL[0], gizmoPosL[1], gizmoPosL[2]])
    mc.move(rootGizmoPos[0][0], rootGizmoPos[0][1], rootGizmoPos[0][2], 'LWingUp', a=T)
    mc.parent('gizmo1', 'gizmo2', 'gizmo3', 'gizmo4', 'gizmo5', 'gizmo6', 'gizmo7', 'gizmo8', 'gizmo9', 'gizmo10', 'gizmo11', 'gizmo12', 'gizmo13', 'gizmo14', 'gizmo15', 'gizmo16', 'gizmo17', 'gizmo18', 'gizmo19', 'gizmo20', 'gizmo21', 'LWingUp')
    mc.select(cl=T)
    
def makeJointChain(*args):
    #get values from sliders
    bendVal = mc.floatSliderGrp('bendSldr', q=T, v=T)
    curlVal = mc.floatSliderGrp('curlSldr', q=T, v=T)
    foldVal = mc.floatSliderGrp('foldSldr', q=T, v=T)
    #get all gizmo positions
    allGizmoPos = []
    for i in xrange(1,22):
        currentGizmo = mc.getAttr('gizmo'+str(i)+'.wm')
        allGizmoPos.append([currentGizmo[12], currentGizmo[13], currentGizmo[14]])
    mc.select(cl=T)
    #arm bones
    mc.select(cl=T)
    armBones = []
    for i in xrange(1,6):
        currentJoint = mc.joint(p=(allGizmoPos[i-1][0], allGizmoPos[i-1][1], allGizmoPos[i-1][2]))
        armBones.append(currentJoint)    
    for i in xrange(0,5):
        mc.joint(armBones[i], e=True, zso=True, oj='xyz', sao='yup')        
    #pointer finger
    mc.select(cl=T)        
    poFinger = []
    for i in xrange(6,10):
        currentJoint = mc.joint(p=(allGizmoPos[i-1][0], allGizmoPos[i-1][1], allGizmoPos[i-1][2]))
        poFinger.append(currentJoint)
    for i in xrange(0,4):
        mc.joint(poFinger[i], e=True, zso=True, oj='xyz', sao='yup')    
    #middle finger
    mc.select(cl=T)        
    miFinger = []
    for i in xrange(10,14):
        currentJoint = mc.joint(p=(allGizmoPos[i-1][0], allGizmoPos[i-1][1], allGizmoPos[i-1][2]))
        miFinger.append(currentJoint)
    for i in xrange(0,4):
        mc.joint(miFinger[i], e=True, zso=True, oj='xyz', sao='yup')
    #ring finger
    mc.select(cl=T)   
    riFinger = []
    for i in xrange(14,18):
        currentJoint = mc.joint(p=(allGizmoPos[i-1][0], allGizmoPos[i-1][1], allGizmoPos[i-1][2]))
        riFinger.append(currentJoint)
    for i in xrange(0,4):
        mc.joint(riFinger[i], e=True, zso=True, oj='xyz', sao='yup')
    #pinky finger
    mc.select(cl=T) 
    piFinger = []
    for i in xrange(18,22):
        currentJoint = mc.joint(p=(allGizmoPos[i-1][0], allGizmoPos[i-1][1], allGizmoPos[i-1][2]))
        piFinger.append(currentJoint)
    for i in xrange(0,4):
        mc.joint(piFinger[i], e=True, zso=True, oj='xyz', sao='yup')        
    
    #orient the bones
    for i in xrange(1,6):
        mc.select('gizmo'+str(i), armBones[i-1])
        mc.orientConstraint(o=(0, 0, 0), w=1)
    for i in xrange(6,10):
        mc.select('gizmo'+str(i), poFinger[i-6])
        mc.orientConstraint(o=(0, 0, 0), w=1) 
    for i in xrange(10,14):
        mc.select('gizmo'+str(i), miFinger[i-10])
        mc.orientConstraint(o=(0, 0, 0), w=1)
    for i in xrange(14,18):
        mc.select('gizmo'+str(i), riFinger[i-14])
        mc.orientConstraint(o=(0, 0, 0), w=1)
    for i in xrange(18,22):
        mc.select('gizmo'+str(i), piFinger[i-18])
        mc.orientConstraint(o=(0, 0, 0), w=1)
    #cleanup
    mc.delete('LWingUp')
    for i in xrange(1,6):
        mc.select(armBones[i-1])    
        mc.makeIdentity(a=T, t=1, r=1, s=1, n=2)
    for i in xrange(6,10):
        mc.select(poFinger[i-6])    
        mc.makeIdentity(a=T, t=1, r=1, s=1, n=2)
    for i in xrange(10,14):
        mc.select(miFinger[i-10])    
        mc.makeIdentity(a=T, t=1, r=1, s=1, n=2)
    for i in xrange(14,18):
        mc.select(riFinger[i-14])    
        mc.makeIdentity(a=T, t=1, r=1, s=1, n=2)
    for i in xrange(18,22):
        mc.select(piFinger[i-18])    
        mc.makeIdentity(a=T, t=1, r=1, s=1, n=2)
    mc.select(cl=T)
    mc.parent(poFinger[0], miFinger[0], riFinger[0], piFinger[0], armBones[2])
    mc.select(cl=T)
    #add custom attributes
    mc.addAttr(armBones[2], ln='bend', nn='Bend', at='double', min=-50, max=50, dv=0)
    mc.setAttr(armBones[2]+'.bend', e=T, k=T)
    mc.addAttr(armBones[2], ln='curl', nn='Curl', at='double', min=-50, max=50, dv=0)
    mc.setAttr(armBones[2]+'.curl', e=T, k=T)
    mc.addAttr(armBones[2], ln='fold', nn='Fold', at='double', min=-50, max=50, dv=0)
    mc.setAttr(armBones[2]+'.fold', e=T, k=T)
    #mirror the joints
    mc.select(armBones[0])
    mirArmBones = (mc.mirrorJoint(myz=T, mb=T))
    mirPoFinger = []
    mirMiFinger = []
    mirRiFinger = []
    mirPiFinger = []
    for i in xrange(5,8):
        mirPoFinger.append(mirArmBones[i])
    for i in xrange(9,12):
        mirMiFinger.append(mirArmBones[i])
    for i in xrange(13,16):
        mirRiFinger.append(mirArmBones[i])
    for i in xrange(17,20):
        mirPiFinger.append(mirArmBones[i])

#driven keyframes
#==============|
#BEND attribute|
#==============|
#zeroed out
    #set pointer finger
    mc.setDrivenKeyframe(poFinger[0]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPoFinger[0]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(poFinger[1]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPoFinger[1]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(poFinger[2]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPoFinger[2]+'.rz' ,cd=mirArmBones[2]+'.bend')
    #set middle finger
    mc.setDrivenKeyframe(miFinger[0]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirMiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(miFinger[1]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirMiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(miFinger[2]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirMiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.bend')
    #set ring finger
    mc.setDrivenKeyframe(riFinger[0]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirRiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(riFinger[1]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirRiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(riFinger[2]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirRiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.bend')
    #set pinky finger
    mc.setDrivenKeyframe(piFinger[0]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(piFinger[1]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(piFinger[2]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.bend')

#////////////////////////////////////////////////////////////////////////////////////////////////////////////
#max upwards
    mc.setAttr(armBones[2]+'.bend', 50.0)
    mc.setAttr(mirArmBones[2]+'.bend', 50.0)
    #adjust pointer finger
    mc.setAttr(poFinger[0]+'.rz', bendVal)
    mc.setAttr(mirPoFinger[0]+'.rz', bendVal)
    mc.setAttr(poFinger[1]+'.rz', bendVal)
    mc.setAttr(mirPoFinger[1]+'.rz', bendVal)
    mc.setAttr(poFinger[2]+'.rz', bendVal)
    mc.setAttr(mirPoFinger[2]+'.rz', bendVal)
    #adjust middle finger
    mc.setAttr(miFinger[0]+'.rz', bendVal)
    mc.setAttr(mirMiFinger[0]+'.rz', bendVal)
    mc.setAttr(miFinger[1]+'.rz', bendVal)
    mc.setAttr(mirMiFinger[1]+'.rz', bendVal)
    mc.setAttr(miFinger[2]+'.rz', bendVal)
    mc.setAttr(mirMiFinger[2]+'.rz', bendVal)
    #adjust ring finger
    mc.setAttr(riFinger[0]+'.rz', bendVal)
    mc.setAttr(mirRiFinger[0]+'.rz', bendVal)
    mc.setAttr(riFinger[1]+'.rz', bendVal)
    mc.setAttr(mirRiFinger[1]+'.rz', bendVal)
    mc.setAttr(riFinger[2]+'.rz', bendVal)
    mc.setAttr(mirRiFinger[2]+'.rz', bendVal)
    #adjust pinky finger
    mc.setAttr(piFinger[0]+'.rz', bendVal)
    mc.setAttr(mirPiFinger[0]+'.rz', bendVal)
    mc.setAttr(piFinger[1]+'.rz', bendVal)
    mc.setAttr(mirPiFinger[1]+'.rz', bendVal)
    mc.setAttr(piFinger[2]+'.rz', bendVal)
    mc.setAttr(mirPiFinger[2]+'.rz', bendVal)
    #set pointer finger
    mc.setDrivenKeyframe(poFinger[0]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPoFinger[0]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(poFinger[1]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPoFinger[1]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(poFinger[2]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPoFinger[2]+'.rz' ,cd=mirArmBones[2]+'.bend')
    #set middle finger
    mc.setDrivenKeyframe(miFinger[0]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirMiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(miFinger[1]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirMiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(miFinger[2]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirMiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.bend')
    #set ring finger
    mc.setDrivenKeyframe(riFinger[0]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirRiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(riFinger[1]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirRiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(riFinger[2]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirRiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.bend')
    #set pinky finger
    mc.setDrivenKeyframe(piFinger[0]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(piFinger[1]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(piFinger[2]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setAttr(armBones[2]+'.bend', 0.0)
    mc.setAttr(mirArmBones[2]+'.bend', 0.0)

#////////////////////////////////////////////////////////////////////////////////////////////////////////////    
#max downwards
    mc.setAttr(armBones[2]+'.bend', -50.0)
    mc.setAttr(mirArmBones[2]+'.bend', -50.0)
    #adjust pointer finger
    mc.setAttr(poFinger[0]+'.rz', -bendVal)
    mc.setAttr(mirPoFinger[0]+'.rz', -bendVal)
    mc.setAttr(poFinger[1]+'.rz', -bendVal)
    mc.setAttr(mirPoFinger[1]+'.rz', -bendVal)
    mc.setAttr(poFinger[2]+'.rz', -bendVal)
    mc.setAttr(mirPoFinger[2]+'.rz', -bendVal)
    #adjust middle finger
    mc.setAttr(miFinger[0]+'.rz', -bendVal)
    mc.setAttr(mirMiFinger[0]+'.rz', -bendVal)
    mc.setAttr(miFinger[1]+'.rz', -bendVal)
    mc.setAttr(mirMiFinger[1]+'.rz', -bendVal)
    mc.setAttr(miFinger[2]+'.rz', -bendVal)
    mc.setAttr(mirMiFinger[2]+'.rz', -bendVal)
    #adjust ring finger
    mc.setAttr(riFinger[0]+'.rz', -bendVal)
    mc.setAttr(mirRiFinger[0]+'.rz', -bendVal)
    mc.setAttr(riFinger[1]+'.rz', -bendVal)
    mc.setAttr(mirRiFinger[1]+'.rz', -bendVal)
    mc.setAttr(riFinger[2]+'.rz', -bendVal)
    mc.setAttr(mirRiFinger[2]+'.rz', -bendVal)
    #adjust pinky finger
    mc.setAttr(piFinger[0]+'.rz', -bendVal)
    mc.setAttr(mirPiFinger[0]+'.rz', -bendVal)
    mc.setAttr(piFinger[1]+'.rz', -bendVal)
    mc.setAttr(mirPiFinger[1]+'.rz', -bendVal)
    mc.setAttr(piFinger[2]+'.rz', -bendVal)
    mc.setAttr(mirPiFinger[2]+'.rz', -bendVal)
    #set pointer finger
    mc.setDrivenKeyframe(poFinger[0]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPoFinger[0]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(poFinger[1]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPoFinger[1]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(poFinger[2]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPoFinger[2]+'.rz' ,cd=mirArmBones[2]+'.bend')
    #set middle finger
    mc.setDrivenKeyframe(miFinger[0]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirMiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(miFinger[1]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirMiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(miFinger[2]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirMiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.bend')
    #set ring finger
    mc.setDrivenKeyframe(riFinger[0]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirRiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(riFinger[1]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirRiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(riFinger[2]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirRiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.bend')
    #set pinky finger
    mc.setDrivenKeyframe(piFinger[0]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(piFinger[1]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setDrivenKeyframe(piFinger[2]+'.rz' ,cd=armBones[2]+'.bend')
    mc.setDrivenKeyframe(mirPiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.bend')
    mc.setAttr(armBones[2]+'.bend', 0.0)
    mc.setAttr(mirArmBones[2]+'.bend', 0.0)

#==============|
#CURL attribute|
#==============|
#zeroed out
    #set pointer finger
    mc.setDrivenKeyframe(poFinger[0]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPoFinger[0]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(poFinger[1]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPoFinger[1]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(poFinger[2]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPoFinger[2]+'.rz' ,cd=mirArmBones[2]+'.curl')
    #set middle finger
    mc.setDrivenKeyframe(miFinger[0]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirMiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(miFinger[1]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirMiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(miFinger[2]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirMiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.curl')
    #set ring finger
    mc.setDrivenKeyframe(riFinger[0]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirRiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(riFinger[1]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirRiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(riFinger[2]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirRiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.curl')
    #set pinky finger
    mc.setDrivenKeyframe(piFinger[0]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(piFinger[1]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(piFinger[2]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.curl')

#////////////////////////////////////////////////////////////////////////////////////////////////////////////
#max upwards
    mc.setAttr(armBones[2]+'.curl', 50.0)
    mc.setAttr(mirArmBones[2]+'.curl', 50.0)
    #adjust pointer finger
    mc.setAttr(poFinger[0]+'.rz', curlVal)
    mc.setAttr(mirPoFinger[0]+'.rz', curlVal)
    mc.setAttr(poFinger[1]+'.rz', curlVal)
    mc.setAttr(mirPoFinger[1]+'.rz', curlVal)
    mc.setAttr(poFinger[2]+'.rz', curlVal)
    mc.setAttr(mirPoFinger[2]+'.rz', curlVal)
    #adjust middle finger
    mc.setAttr(miFinger[0]+'.rz', (curlVal*0.5))
    mc.setAttr(mirMiFinger[0]+'.rz', (curlVal*0.5))
    mc.setAttr(miFinger[1]+'.rz', (curlVal*0.5))
    mc.setAttr(mirMiFinger[1]+'.rz', (curlVal*0.5))
    mc.setAttr(miFinger[2]+'.rz', (curlVal*0.5))
    mc.setAttr(mirMiFinger[2]+'.rz', (curlVal*0.5))
    #adjust ring finger
    mc.setAttr(riFinger[0]+'.rz', 0.0)
    mc.setAttr(mirRiFinger[0]+'.rz', 0.0)
    mc.setAttr(riFinger[1]+'.rz', (curlVal*0.25))
    mc.setAttr(mirRiFinger[1]+'.rz', (curlVal*0.25))
    mc.setAttr(riFinger[2]+'.rz', (curlVal*0.25))
    mc.setAttr(mirRiFinger[2]+'.rz', (curlVal*0.25))
    #adjust pinky finger
    mc.setAttr(piFinger[0]+'.rz', (curlVal*-0.25))
    mc.setAttr(mirPiFinger[0]+'.rz', (curlVal*-0.25))
    mc.setAttr(piFinger[1]+'.rz', (curlVal*0.25))
    mc.setAttr(mirPiFinger[1]+'.rz', (curlVal*0.25))
    mc.setAttr(piFinger[2]+'.rz', (curlVal*0.25))
    mc.setAttr(mirPiFinger[2]+'.rz', (curlVal*0.25))
    #set pointer finger
    mc.setDrivenKeyframe(poFinger[0]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPoFinger[0]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(poFinger[1]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPoFinger[1]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(poFinger[2]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPoFinger[2]+'.rz' ,cd=mirArmBones[2]+'.curl')
    #set middle finger
    mc.setDrivenKeyframe(miFinger[0]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirMiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(miFinger[1]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirMiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(miFinger[2]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirMiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.curl')
    #set ring finger
    mc.setDrivenKeyframe(riFinger[0]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirRiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(riFinger[1]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirRiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(riFinger[2]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirRiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.curl')
    #set pinky finger
    mc.setDrivenKeyframe(piFinger[0]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(piFinger[1]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(piFinger[2]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setAttr(armBones[2]+'.curl', 0.0)
    mc.setAttr(mirArmBones[2]+'.curl', 0.0)

#////////////////////////////////////////////////////////////////////////////////////////////////////////////    
#max downwards
    mc.setAttr(armBones[2]+'.curl', -50.0)
    mc.setAttr(mirArmBones[2]+'.curl', -50.0)
    #adjust pointer finger
    mc.setAttr(poFinger[0]+'.rz', -curlVal)
    mc.setAttr(mirPoFinger[0]+'.rz', -curlVal)
    mc.setAttr(poFinger[1]+'.rz', -curlVal)
    mc.setAttr(mirPoFinger[1]+'.rz', -curlVal)
    mc.setAttr(poFinger[2]+'.rz', -curlVal)
    mc.setAttr(mirPoFinger[2]+'.rz', -curlVal)
    #adjust middle finger
    mc.setAttr(miFinger[0]+'.rz', (curlVal*-0.5))
    mc.setAttr(mirMiFinger[0]+'.rz', (curlVal*-0.5))
    mc.setAttr(miFinger[1]+'.rz', (curlVal*-0.5))
    mc.setAttr(mirMiFinger[1]+'.rz', (curlVal*-0.5))
    mc.setAttr(miFinger[2]+'.rz', (curlVal*-0.5))
    mc.setAttr(mirMiFinger[2]+'.rz', (curlVal*-0.5))
    #adjust ring finger
    mc.setAttr(riFinger[0]+'.rz', 0.0)
    mc.setAttr(mirRiFinger[0]+'.rz', 0.0)
    mc.setAttr(riFinger[1]+'.rz', (curlVal*-0.25))
    mc.setAttr(mirRiFinger[1]+'.rz', (curlVal*-0.25))
    mc.setAttr(riFinger[2]+'.rz', (curlVal*-0.25))
    mc.setAttr(mirRiFinger[2]+'.rz', (curlVal*-0.25))
    #adjust pinky finger
    mc.setAttr(piFinger[0]+'.rz', (curlVal*0.25))
    mc.setAttr(mirPiFinger[0]+'.rz', (curlVal*0.25))
    mc.setAttr(piFinger[1]+'.rz', (curlVal*-0.25))
    mc.setAttr(mirPiFinger[1]+'.rz', (curlVal*-0.25))
    mc.setAttr(piFinger[2]+'.rz', (curlVal*-0.25))
    mc.setAttr(mirPiFinger[2]+'.rz', (curlVal*-0.25))
    #set pointer finger
    mc.setDrivenKeyframe(poFinger[0]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPoFinger[0]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(poFinger[1]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPoFinger[1]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(poFinger[2]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPoFinger[2]+'.rz' ,cd=mirArmBones[2]+'.curl')
    #set middle finger
    mc.setDrivenKeyframe(miFinger[0]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirMiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(miFinger[1]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirMiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(miFinger[2]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirMiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.curl')
    #set ring finger
    mc.setDrivenKeyframe(riFinger[0]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirRiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(riFinger[1]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirRiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(riFinger[2]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirRiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.curl')
    #set pinky finger
    mc.setDrivenKeyframe(piFinger[0]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPiFinger[0]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(piFinger[1]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPiFinger[1]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setDrivenKeyframe(piFinger[2]+'.rz' ,cd=armBones[2]+'.curl')
    mc.setDrivenKeyframe(mirPiFinger[2]+'.rz' ,cd=mirArmBones[2]+'.curl')
    mc.setAttr(armBones[2]+'.curl', 0.0)
    mc.setAttr(mirArmBones[2]+'.curl', 0.0)

#==============|
#FOLD attribute|
#==============|
#zeroed out
    #set pointer finger
    mc.setDrivenKeyframe(poFinger[0]+'.ry' ,cd=armBones[2]+'.fold')
    mc.setDrivenKeyframe(mirPoFinger[0]+'.ry' ,cd=mirArmBones[2]+'.fold')
    #set middle finger
    mc.setDrivenKeyframe(miFinger[0]+'.ry' ,cd=armBones[2]+'.fold')
    mc.setDrivenKeyframe(mirMiFinger[0]+'.ry' ,cd=mirArmBones[2]+'.fold')
    #set ring finger
    mc.setDrivenKeyframe(riFinger[0]+'.ry' ,cd=armBones[2]+'.fold')
    mc.setDrivenKeyframe(mirRiFinger[0]+'.ry' ,cd=mirArmBones[2]+'.fold')
    #set pinky finger
    mc.setDrivenKeyframe(piFinger[0]+'.ry' ,cd=armBones[2]+'.fold')
    mc.setDrivenKeyframe(mirPiFinger[0]+'.ry' ,cd=mirArmBones[2]+'.fold')
    
#////////////////////////////////////////////////////////////////////////////////////////////////////////////
#unfolded
    mc.setAttr(armBones[2]+'.fold', 50.0)
    mc.setAttr(mirArmBones[2]+'.fold', 50.0)
    #adjust pointer finger
    mc.setAttr(poFinger[0]+'.ry', (foldVal*-0.357))
    mc.setAttr(mirPoFinger[0]+'.ry', (foldVal*-0.357))
    #adjust middle finger
    mc.setAttr(miFinger[0]+'.ry', (foldVal*-0.286))
    mc.setAttr(mirMiFinger[0]+'.ry', (foldVal*-0.286))
    #adjust ring finger
    mc.setAttr(riFinger[0]+'.ry', (foldVal*-0.214))
    mc.setAttr(mirRiFinger[0]+'.ry', (foldVal*-0.214))
    #adjust pinky finger
    mc.setAttr(piFinger[0]+'.ry', (foldVal*-0.143))
    mc.setAttr(mirPiFinger[0]+'.ry', (foldVal*-0.143))
    #set pointer finger
    mc.setDrivenKeyframe(poFinger[0]+'.ry' ,cd=armBones[2]+'.fold')
    mc.setDrivenKeyframe(mirPoFinger[0]+'.ry' ,cd=mirArmBones[2]+'.fold')
    #set middle finger
    mc.setDrivenKeyframe(miFinger[0]+'.ry' ,cd=armBones[2]+'.fold')
    mc.setDrivenKeyframe(mirMiFinger[0]+'.ry' ,cd=mirArmBones[2]+'.fold')
    #set ring finger
    mc.setDrivenKeyframe(riFinger[0]+'.ry' ,cd=armBones[2]+'.fold')
    mc.setDrivenKeyframe(mirRiFinger[0]+'.ry' ,cd=mirArmBones[2]+'.fold')
    #set pinky finger
    mc.setDrivenKeyframe(piFinger[0]+'.ry' ,cd=armBones[2]+'.fold')
    mc.setDrivenKeyframe(mirPiFinger[0]+'.ry' ,cd=mirArmBones[2]+'.fold')
    mc.setAttr(armBones[2]+'.fold', 0.0)
    mc.setAttr(mirArmBones[2]+'.fold', 0.0)

#////////////////////////////////////////////////////////////////////////////////////////////////////////////    
#folded
    mc.setAttr(armBones[2]+'.fold', -50.0)
    mc.setAttr(mirArmBones[2]+'.fold', -50.0)
    #adjust pointer finger
    mc.setAttr(poFinger[0]+'.ry', foldVal)
    mc.setAttr(mirPoFinger[0]+'.ry', foldVal)
    #adjust middle finger
    mc.setAttr(miFinger[0]+'.ry', (foldVal*0.929))
    mc.setAttr(mirMiFinger[0]+'.ry', (foldVal*0.929))
    #adjust ring finger
    mc.setAttr(riFinger[0]+'.ry', (foldVal*0.857))
    mc.setAttr(mirRiFinger[0]+'.ry', (foldVal*0.857))
    #adjust pinky finger
    mc.setAttr(piFinger[0]+'.ry', (foldVal*0.714))
    mc.setAttr(mirPiFinger[0]+'.ry', (foldVal*0.714))
    #set pointer finger
    mc.setDrivenKeyframe(poFinger[0]+'.ry' ,cd=armBones[2]+'.fold')
    mc.setDrivenKeyframe(mirPoFinger[0]+'.ry' ,cd=mirArmBones[2]+'.fold')
    #set middle finger
    mc.setDrivenKeyframe(miFinger[0]+'.ry' ,cd=armBones[2]+'.fold')
    mc.setDrivenKeyframe(mirMiFinger[0]+'.ry' ,cd=mirArmBones[2]+'.fold')
    #set ring finger
    mc.setDrivenKeyframe(riFinger[0]+'.ry' ,cd=armBones[2]+'.fold')
    mc.setDrivenKeyframe(mirRiFinger[0]+'.ry' ,cd=mirArmBones[2]+'.fold')
    #set pinky finger
    mc.setDrivenKeyframe(piFinger[0]+'.ry' ,cd=armBones[2]+'.fold')
    mc.setDrivenKeyframe(mirPiFinger[0]+'.ry' ,cd=mirArmBones[2]+'.fold')
    mc.setAttr(armBones[2]+'.fold', 0.0)
    mc.setAttr(mirArmBones[2]+'.fold', 0.0)
            
    print('done setting')
    mc.delete('rMat')
    mc.delete('gMat')
    mc.delete('bMat')
    mc.select(cl=T)
    
if mc.window('DB Quick Wing!', exists=F):
    quickWingWin = mc.window(title='DB Quick Wing!', iconName='testWin', w=(500), h=(200), s=F, ret=T)
    mc.columnLayout(adjustableColumn=T)
    mc.floatSliderGrp('bendSldr', label='Bend Amount', field=True, minValue=0, maxValue=50.0, value=25, cal=(1, 'left'), cw3=(80, 50, 100) )
    mc.floatSliderGrp('curlSldr', label='Curl Amount', field=True, minValue=0, maxValue=45.0, value=20, cal=(1, 'left'), cw3=(80, 50, 100) )
    mc.floatSliderGrp('foldSldr', label='Fold Amount', field=True, minValue=0, maxValue=80.0, value=70, cal=(1, 'left'), cw3=(80, 50, 100) )
    mc.button(label='Make Gizmo Chain', c=makeGizmoChain)
    mc.button(label='Make Joint Chain', c=makeJointChain)
def quickwing():
    mc.showWindow(quickWingWin)

Simple Enemy Space Ship AI

 

Phoenix (3 Artist Team):

In order for artists to get acquainted with game scripting and coding, we were placed in small teams and tasked with making a Unity game using its Javascript based language. A movement system with a full 6 degrees of freedom was implemented, which was particularly tricky with the AI. Quaternions were used rather than Euler angles to avoid Gimbal lock. The AI is designed so that they prefer to circle the player by changing their yaw rather than their pitch, so they tend to stay on a horizontal plane rather than taking steep pitch angles. This works rather well in practice, as the ships appear to be very agile.

What I Did:

  • AI

  • Ship Movement

  • Various Scripting (ex: Timing Explosions)

  • Particle Systems

  • Shader Work

  • Integration of the team scripts into the final build

 

            
//for finding the player location and other important locations
var missionZoneCenter : Transform;
var myTransform : Transform;
var playerShip : GameObject;
var delayedBlast2 : Transform;
//for moving
var turnSpeed : int = 4;
var thrust : int = 25;
private var fullThrottle : boolean = true;
//for finding angle to the player
private var positionDifference;
private var rotateToPlayer;
//AI variables
var canShoot : boolean = true;
var distToMissionZone : float;
var distToPlayer : float;
var playerVelocity : float;
var enemyVelocity : float;
var thinking : int = 3;
var randomize : boolean = true;
var randomizer : int;
//for positions in space relative to the player. The offset is to make it less straight forward forcing the player to maneuver since the enemy is tracking points in space around the player. Also, it greatly reduces the chance the player will ever collide with an enemy.
var xOffset : int = 300;
var yOffset : int = 300;
var zOffset : int = 300;
var aboveFront : Vector3;
var farBehind : Vector3;
var farLeft : Vector3;
var leadPlayer : Transform;
var playerPosition : Vector3;
var offsetPosition : Vector3;

function Awake () {
	myTransform = transform;
}

function Start (){
	RandomNumber ();
	//fill in name of player ship here \/
	playerShip = GameObject.Find("aTridentB");
	//tell it where those positions relative to the player are
	aboveFront = Vector3(0, -yOffset+randomizer, zOffset);
	farBehind = Vector3(0, randomizer, -zOffset*10);
	farLeft = Vector3(xOffset, 0, 0);
	gameObject.BroadcastMessage ("GunOnOff", false);
}

function Update (){
	distToPlayer = Vector3.Distance(playerShip.transform.position, myTransform.position);
	distToMissionZone = Vector3.Distance(missionZoneCenter.position, myTransform.position);
	playerPosition = playerShip.transform.localPosition;
	//pick a random number every 5 seconds goes to the function to do this
	if (randomize) {
		randomize = false;
		RandomNumber ();
	}
}


function FixedUpdate (){
	//for determining AI state look at a random number and the distance from the player
	if(distToPlayer > 300) {
		thinking = 4;
	}
	
	else if( randomizer >= 20)
	{
		if( distToPlayer < 20 ){
			thinking = 4;
		}
		if( distToMissionZone > 400 && randomizer < 27) {
			thinking = 4;
		}
		if( distToPlayer > 125 ){
			thinking = 3;
		}
		if( randomizer >= 28 && distToPlayer < 110 ){
			thinking = 2;
		}
		else if( randomizer < 27 && distToPlayer < 80 ){
			thinking = 3;
		}
		else if( randomizer == 27 && distToPlayer < 80 ){
			thinking = 0;
		}
	}
	else
	{
		if( distToPlayer < 20 ){
			thinking = 4;
		}
		if( distToMissionZone > 400 && randomizer <= 7) {
			thinking = 4;
		}
		if( distToPlayer > 125 ){
			thinking = 3;
		}
		if( randomizer <= 7 && distToPlayer < 80 ){
			thinking = 3;
		}
		else if( randomizer >= 8 && distToPlayer < 110 ){
			thinking = 1;
		}
	}
	//functions to call on the different states
	switch(thinking){
		case 0 : GetBehind ();
		break;
		case 1 : GetFront ();
		break;
		case 2 : GetLeft ();
		break;
		case 3 : Attack ();
		break;
		case 4 : MissionZone ();
		break;
		default:
		break;
	}
	
	if ( fullThrottle ) {
		rigidbody.AddRelativeForce( 0,0,thrust );
	}
	rotateToPlayer = Quaternion.LookRotation( positionDifference );
	transform.rotation = Quaternion.Slerp ( myTransform.rotation, rotateToPlayer, 
Mathf.Lerp(0, turnSpeed, Time.deltaTime/10) );
	//debug for fine tuning the behavior
	//print ("Distance to player: " + distToPlayer);
	//print( rotateToPlayer.eulerAngles - myTransform.rotation.eulerAngles );
}

function RandomNumber (){
	randomizer = Random.Range( 1, 30 );
	//print(randomizer);
	yield WaitForSeconds(7);
	randomize = true;
}

function GetBehind (){
	gameObject.BroadcastMessage ("GunOnOff", false);
	offsetPosition = playerPosition + farBehind;
	positionDifference = offsetPosition - myTransform.position;
}

function GetFront (){
	gameObject.BroadcastMessage ("GunOnOff", false);
	offsetPosition = playerPosition + aboveFront;
	positionDifference = offsetPosition - myTransform.position;
}

function GetLeft (){
	gameObject.BroadcastMessage ("GunOnOff", false);
	offsetPosition = playerPosition + farLeft;
	positionDifference = offsetPosition - myTransform.position;
}

function Attack (){
	if (distToPlayer < 300) {
		//talk to the gun :)
		gameObject.BroadcastMessage ("GunOnOff", true);
	}
	//very rough method for leading the player, works best when the enemy is approaching from behind. For every enemy the player is tracking infront of them at least one enemy will be in a state to attack from behind.
	offsetPosition = leadPlayer.position;
	positionDifference = offsetPosition - myTransform.position;
}

function MissionZone (){
	//you're off the grid! get back!
	gameObject.BroadcastMessage ("GunOnOff", false);
	offsetPosition = missionZoneCenter.position;
	positionDifference = offsetPosition - myTransform.position;
}

function BigBoom() {
	//fall down go boom :(
	Instantiate(delayedBlast2, myTransform.position, myTransform.rotation);
}