using UnityEngine;
using System.Collections;
using System;


public class DeformScript : MonoBehaviour 
{
	private const float ONE_HALF				= 0.5f; 
	private const float BODY_YAW_ROTATION		= 90.0f;
	private const float AMOUNT_OF_PERLIN_NOISE	= 0.8f;
	private const float	MAX_STRENGTH			= 5.0f;

	//--------------------------------------
	// names for the poses
	//--------------------------------------
//	private const int NEUTRAL_POSE	= 0;
//	private const int LOW_POSE		= 1;
//	private const int HIGH_POSE		= 2;
//	private const int CLOSED_POSE	= 3;
//	private const int OPEN_POSE		= 4;
	private const int NUM_POSES		= 5;

	//---------------------------------------------
	// names for the joints
	//---------------------------------------------
	private const int HIP_JOINT						=  0;
	private const int LEFT_UPPER_LEG_JOINT			=  1;
	private const int LEFT_LOWER_LEG_JOINT			=  2;
	private const int LEFT_FOOT_JOINT				=  3;
	private const int LEFT_BALL_JOINT				=  4;
	private const int LEFT_TOE_JOINT				=  5;
	private const int RIGHT_UPPER_LEG_JOINT			=  6;
	private const int RIGHT_LOWER_LEG_JOINT			=  7;
	private const int RIGHT_FOOT_JOINT				=  8;
	private const int RIGHT_BALL_JOINT				=  9;
	private const int RIGHT_TOE_JOINT				= 10;
	private const int SPINE_1_JOINT					= 11;
	private const int SPINE_2_JOINT					= 12;
	private const int SPINE_3_JOINT					= 13;
	private const int SHOULDER_JOINT				= 14;
	private const int LEFT_SHOULDER_BLADE_JOINT		= 15;
	private const int LEFT_UPPER_ARM_JOINT			= 16;
	private const int LEFT_LOWER_ARM_JOINT			= 17;
	private const int LEFT_WRIST_JOINT				= 18;
	private const int LEFT_GRIP_JOINT				= 19;
	private const int LEFT_FINGERS_JOINT			= 20;
	private const int LEFT_THUMB_BASE_JOINT			= 21;
	private const int LEFT_THUMB_BEND_JOINT			= 22;
	private const int LEFT_THUMB_TIP_JOINT			= 23;
	private const int RIGHT_SHOULDER_BLADE_JOINT	= 24;
	private const int RIGHT_UPPER_ARM_JOINT			= 25;
	private const int RIGHT_LOWER_ARM_JOINT			= 26;
	private const int RIGHT_WRIST_JOINT				= 27;
	private const int RIGHT_GRIP_JOINT				= 28;
	private const int RIGHT_FINGERS_JOINT			= 29;
	private const int RIGHT_THUMB_BASE_JOINT		= 30;
	private const int RIGHT_THUMB_BEND_JOINT		= 31;
	private const int RIGHT_THUMB_TIP_JOINT			= 32;
	private const int NECK_JOINT					= 33;
	private const int HEAD_JOINT					= 34;
	private const int NUM_JOINTS					= 35;

	//---------------------------------------------
	// names for the emotions
	//---------------------------------------------	
	private const int NEUTRAL						= 0;
	private const int HAPPINESS						= 1;
	private const int PRIDE							= 2;
	private const int SADNESS						= 3;
	private const int FEAR							= 4;
	private const int ANGER							= 5;
	private const int CONTEMPT						= 6;
	private const int SHAME							= 7;
	private const int GUILT							= 8;
	private const int NUM_EMOTIONS 				  	= 9;
	
	private static string[] emotions = new string[NUM_EMOTIONS] {"Neutral", "Happiness", "Pride", "Sadness", "Fear", "Anger", "Contempt", "Shame", "Guilt"};   	
	// set up currentSelection at a scope that allows for initial selection one time
	string currentSelection = emotions[0];	
	
	public	Transform[] joints;
	public	float		publicTwist		= 0.5f; // need to ask about this
	public	float		publicSideBend	= 0.5f; // here business

	//---------------------------------------------
	// settings for the GUI boxes
	//---------------------------------------------
	private const int guiRectHeight = 210;
	private const int guiRectWidth  = 250;
	private	const int guiRecty		= 480;
	private	Rect	guiRect1	= new Rect( 20, guiRecty, guiRectWidth, guiRectHeight );
	private	Rect	guiRect2	= new Rect( 500, guiRecty, guiRectWidth, guiRectHeight );
	
	private Pose[]	pose		= new Pose[ NUM_POSES ];
	private DelsarteAvatar avatar	= new DelsarteAvatar();
	public string avatarName;	

	//-----------------------------------------------
	// names for the Delsarte grand and sub divisions
	//-----------------------------------------------
	private const int CONCENTRIC = 1;
	private const int NORMAL = 2;
	private const int EXCENTRIC = 3;
	
	//---------------------------------------------------------	
	
	//--------------------------------
	// SelectList class - a custom GUI object that provides a linked set of checkboxes
	// http://www.unifycommunity.com/wiki/index.php?title=SelectList
	//--------------------------------
	public static object SelectList( ICollection list, object selected, GUIStyle defaultStyle, GUIStyle selectedStyle )
	{         
		foreach( object item in list )
		{
			if( GUILayout.Button( item.ToString(), ( selected == item ) ? selectedStyle : defaultStyle ) )
			{
				if( selected == item )
                // Clicked an already selected item. Deselect.
                {
                	selected = null;
                }
                else
                {
                	selected = item;
                }
			}
		}
       
		return selected;	
	}
       
	public delegate bool OnListItemGUI( object item, bool selected, ICollection list );
       
	public static object SelectList( ICollection list, object selected, OnListItemGUI itemHandler )
	{
		ArrayList itemList;
           
		itemList = new ArrayList( list );
           
		foreach( object item in itemList )
		{
			if( itemHandler( item, item == selected, list ) )
			{
				selected = item;
			}
			else if( selected == item )
			// If we *were* selected, but aren't any more then deselect
			{
				selected = null;
			}
		}
       
		return selected;
	}
	
	//--------------------------------
	// Pose class 
	//--------------------------------
	class Pose
	{
		float[] yaw		= new float[ NUM_JOINTS ];
		float[] pitch	= new float[ NUM_JOINTS ];
		float[] roll	= new float[ NUM_JOINTS ];
		
		public Pose()
		{
			for (int j=0; j<NUM_JOINTS; j++)
			{
				yaw		[j] = 0.0f;
				pitch	[j] = 0.0f;
				roll	[j] = 0.0f;
			}
		}
		
		public void setJointRotation( int jointIndex, float y, float p, float r )
		{
			yaw		[ jointIndex ] = y;
			pitch	[ jointIndex ] = p;
			roll	[ jointIndex ] = r;
		}

		public float getYaw		( int jointIndex ) { return yaw		[ jointIndex ]; }
		public float getPitch	( int jointIndex ) { return pitch	[ jointIndex ]; }
		public float getRoll	( int jointIndex ) { return roll	[ jointIndex ]; }
		
	} //---------------------------------------------------
	 // end of Pose class
	//-----------------------------------------------------

	class EmotionalStatus {
		public int emotion;
		public int strength;
		public bool sincerity;

		// we get away without error checking because everything comes in from GUI input
		public EmotionalStatus(int emo, int str, bool sinc)
		{
			emotion = emo;
			strength = str;
			sincerity = sinc;
		}	
		
//		public int getEmotion() { return emotion; }
//		public int getStrength() { return strength; }
//		public bool getSincerity() { return sincerity; }
//		
//		public void setEmotion(int emo) { emotion = emo; }
//		public void setStrength(int str) { strength = str; }
//		public void setSincerity(bool sinc) {sincerity = sinc; }
	}	
	
	//--------------------------------
	// Avatar class
	//--------------------------------
	class Avatar
	{
		public	float	forwardBend	= 0.5f;
		public	float	sideBend	= 0.5f;
		public	float	facing		= 0.5f;
	 
	} //--------------------------------


	//--------------------------------
	// DelsarteAvatar class
	//  will hold DelsarteRegions, and pose in Delsarte ways
	//--------------------------------
	class DelsarteAvatar:Avatar
	{
		public EmotionalStatus emotional_status; 
		public Torso t; 
		public ArmsHands ah; 
		public Head h; 
		public Legs l;
		
		// default constructor
		public DelsarteAvatar() 
		{
			emotional_status = new EmotionalStatus(NEUTRAL, 0, true);
			t = new Torso();
			ah = new ArmsHands();
			h = new Head();
			l = new Legs();
		}
		
		public void setDelsarteDivisions() 
		{
//			t.setDelsarteDivisions(emotional_status);
			ah.setDelsarteDivisions(emotional_status);
			h.setDelsarteDivisions(emotional_status);
			l.setDelsarteDivisions(emotional_status);	
		}
		
		public void updateJoints(ref Transform[] joints)
		{						
			t.setJoints(emotional_status, ref joints);
			ah.setJoints(emotional_status, ref joints);
			h.setJoints(emotional_status, ref joints);
			l.setJoints(emotional_status, ref joints, facing);
		}
	} //--------------------------------
		
	//--------------------------------
	// DelsarteRegion class
	//  top-level methods for regions
	//--------------------------------
	class DelsarteRegion
	{
		private int current_grand_division;
		private int current_sub_division;
		
		public DelsarteRegion() {
			
		}
		
		public void setCurrentDivisions (int grand, int sub)
		{
			current_grand_division = grand;
			current_sub_division = sub;
		}
		
		public int getGrandDivision() { return current_grand_division; }
		public int getSubDivision() { return current_sub_division; }
		
		// good old fashioned randomness
		public Vector3 addPerlinNoise(float x_angle, float y_angle, float z_angle, int joint_index)
		{
			float new_x = x_angle + AMOUNT_OF_PERLIN_NOISE * Mathf.Sin( Time.time * 1.6f + joint_index * 8.0f );	
			float new_y = y_angle + AMOUNT_OF_PERLIN_NOISE * Mathf.Sin( Time.time * 2.4f + joint_index * 8.0f );
			float new_z = z_angle + AMOUNT_OF_PERLIN_NOISE * Mathf.Sin( Time.time * 4.0f + joint_index * 8.0f );
			return new Vector3(new_x, new_y, new_z);
		}
		
	} //--------------------------------
		
	//--------------------------------
	// DelsarteRegions subclasses
	//  contains specific posing information for joints in that region
	//  the commented-out joint constants preceed the applicable region as reminders
	//--------------------------------	
	class Torso:DelsarteRegion {
		
//	private const int SPINE_1_JOINT					= 11;
//	private const int SPINE_2_JOINT					= 12;
//	private const int SPINE_3_JOINT					= 13;		
		// this will act on the specific joints of the torso
		public void setJoints(EmotionalStatus emo, ref Transform[] joints) 
		{

		}
	}
		
	class ArmsHands:DelsarteRegion {
		public void setDelsarteDivisions(EmotionalStatus emo) 
		{
			switch (emo.emotion)
			{
				case NEUTRAL:	
					setCurrentDivisions(NORMAL, NORMAL);
					break;
				case HAPPINESS:
					setCurrentDivisions(EXCENTRIC, NORMAL);
					break;				
				case PRIDE:
					setCurrentDivisions(NORMAL, EXCENTRIC);
					break;
				case SADNESS:
					setCurrentDivisions(NORMAL, CONCENTRIC);
					break;				
				case FEAR:
					setCurrentDivisions(CONCENTRIC, CONCENTRIC);
					break;				
				case ANGER:
					setCurrentDivisions(EXCENTRIC, EXCENTRIC);
					break;				
				case CONTEMPT:
					setCurrentDivisions(CONCENTRIC, NORMAL);
					break;				
				case SHAME:
					setCurrentDivisions(EXCENTRIC, CONCENTRIC);
					break;				
				case GUILT:
					setCurrentDivisions(EXCENTRIC, CONCENTRIC);
					break;				
				default: 
					Debug.Log("Something went wrong, undefined emotion");
					break;			
			}
		}

//	private const int SHOULDER_JOINT				= 14;
//	LEFT ARM
//	private const int LEFT_SHOULDER_BLADE_JOINT		= 15;
//	private const int LEFT_UPPER_ARM_JOINT			= 16;
//	private const int LEFT_LOWER_ARM_JOINT			= 17;
//	private const int LEFT_WRIST_JOINT				= 18;
//	private const int LEFT_GRIP_JOINT				= 19;
//	private const int LEFT_FINGERS_JOINT			= 20;
//	private const int LEFT_THUMB_BASE_JOINT			= 21;
//	private const int LEFT_THUMB_BEND_JOINT			= 22;
//	private const int LEFT_THUMB_TIP_JOINT			= 23;
//  RIGHT ARM
//	private const int RIGHT_SHOULDER_BLADE_JOINT	= 24;
//	private const int RIGHT_UPPER_ARM_JOINT			= 25;
//	private const int RIGHT_LOWER_ARM_JOINT			= 26;
//	private const int RIGHT_WRIST_JOINT				= 27;
//	private const int RIGHT_GRIP_JOINT				= 28;
//	private const int RIGHT_FINGERS_JOINT			= 29;
//	private const int RIGHT_THUMB_BASE_JOINT		= 30;
//	private const int RIGHT_THUMB_BEND_JOINT		= 31;
//	private const int RIGHT_THUMB_TIP_JOINT			= 32;
		public void setJoints(EmotionalStatus emo, ref Transform[] joints)
		{
			// to help adjust the arm position based on emotional strength
			const int ARM_MAX = 80;
			// set the emotional multiplier
			float e_m = emo.strength / MAX_STRENGTH;
			
			int[] U_ARM;
				
			// reset all to avoid mix-ups
			for(int i=14;i<=32;i++)
			{
				joints[i].localEulerAngles = addPerlinNoise(0, 0, 0, i);
			}
								
			if (getGrandDivision() == EXCENTRIC) 
			{
				if (getSubDivision() == EXCENTRIC)
				{
					U_ARM = new int[6]{-60,-40,-20,0,20,40};
					// arms extended their full length in front, level with shoulders
					joints[LEFT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(U_ARM[emo.strength], e_m*75, e_m*-90, LEFT_UPPER_ARM_JOINT);
					joints[LEFT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise(-10, 0, 0, LEFT_LOWER_ARM_JOINT);
					joints[LEFT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise(0, -50, 0, LEFT_THUMB_BASE_JOINT);			
					
					U_ARM = new int[6]{60,40,20,0, -15,-30};							
					joints[RIGHT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(U_ARM[emo.strength], e_m*-75, e_m*-90, RIGHT_UPPER_ARM_JOINT);	
					joints[RIGHT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise(10, 0, 0, RIGHT_LOWER_ARM_JOINT);
					joints[RIGHT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise(0, 50, 0, RIGHT_THUMB_BASE_JOINT);
				} else if (getSubDivision() == NORMAL) 
				{	// arms extended from shoulders in breadths (sides), elbows unbent
					U_ARM = new int[6]{-60,-20, -10, 20, 30, 45};
					// arms extended their full length in front, level with shoulders
					joints[LEFT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(U_ARM[emo.strength], 0, e_m*-100, LEFT_UPPER_ARM_JOINT);
					joints[LEFT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise(-10, 0, 0, LEFT_LOWER_ARM_JOINT);
					joints[LEFT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise(0, -50, 0, LEFT_THUMB_BASE_JOINT);			
					
					U_ARM = new int[6]{60,20, 10, -20, -30,-45};							
					joints[RIGHT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(U_ARM[emo.strength], 0, e_m*-100, RIGHT_UPPER_ARM_JOINT);	
					joints[RIGHT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise(10, 0, 0, RIGHT_LOWER_ARM_JOINT);
					joints[RIGHT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise(0, 50, 0, RIGHT_THUMB_BASE_JOINT);
				} else if (getSubDivision() == CONCENTRIC) 
				{
					// arms hand full length in front of body
					joints[LEFT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(-80, 0, e_m*-40, LEFT_UPPER_ARM_JOINT);
					joints[LEFT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise(e_m*-30, e_m*10, 0, LEFT_LOWER_ARM_JOINT);			
					joints[LEFT_WRIST_JOINT].localEulerAngles = addPerlinNoise(e_m*-40, 0, e_m*80, LEFT_WRIST_JOINT);
					joints[LEFT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise(0, -50, 0, LEFT_THUMB_BASE_JOINT);
					
					joints[RIGHT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(80, 0, e_m*-40, RIGHT_UPPER_ARM_JOINT);
					joints[RIGHT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise(e_m*30, 0, 0, RIGHT_LOWER_ARM_JOINT);
					joints[RIGHT_WRIST_JOINT].localEulerAngles = addPerlinNoise(e_m*40, 0, e_m*80, RIGHT_WRIST_JOINT);
					joints[RIGHT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise(0, 50, 0, RIGHT_THUMB_BASE_JOINT);
				}
			} else if (getGrandDivision() == NORMAL) 
			{
				if (getSubDivision() == EXCENTRIC)
				{
					
					U_ARM = new int[6]{-80,-70,-65,-55, -48, -45};
					// -45
					// elbows bent, hands on hips
					joints[LEFT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(U_ARM[emo.strength], 0, 0, LEFT_UPPER_ARM_JOINT);						
					joints[LEFT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise(e_m*-80, 0, 0, LEFT_LOWER_ARM_JOINT);
					joints[LEFT_WRIST_JOINT].localEulerAngles = addPerlinNoise(e_m*50, 0, 0, LEFT_WRIST_JOINT);
					joints[LEFT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise(0, 0, 0, LEFT_THUMB_BASE_JOINT);					
					U_ARM = new int[6]{80, 70, 65, 55, 48, 45};
					joints[RIGHT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(U_ARM[emo.strength], 0, 0, RIGHT_UPPER_ARM_JOINT);
					joints[RIGHT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise(e_m*80, 0, 0, RIGHT_LOWER_ARM_JOINT);
					joints[RIGHT_WRIST_JOINT].localEulerAngles = addPerlinNoise(e_m*-50, 0, 0, RIGHT_WRIST_JOINT);	
					joints[RIGHT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise(0, 0, 0, RIGHT_THUMB_BASE_JOINT);
				} else if (getSubDivision() == NORMAL) 
				{
					joints[LEFT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(-80, 0, 0, LEFT_UPPER_ARM_JOINT);
					joints[RIGHT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(80, 0, 0, RIGHT_UPPER_ARM_JOINT);
				} else if (getSubDivision() == CONCENTRIC) 
				{
					// arms hang from shoulders at sides
					joints[LEFT_SHOULDER_BLADE_JOINT].localEulerAngles = addPerlinNoise(0, e_m*-15, e_m*-80, LEFT_SHOULDER_BLADE_JOINT);
					joints[LEFT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(-85, e_m*10, 0, LEFT_UPPER_ARM_JOINT);					
					joints[LEFT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise(e_m*10, e_m*130, e_m*40, LEFT_LOWER_ARM_JOINT);
					joints[LEFT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise( 0, -50, 0, LEFT_THUMB_BASE_JOINT);				
					
					joints[RIGHT_SHOULDER_BLADE_JOINT].localEulerAngles = addPerlinNoise(0, e_m*15, e_m*-80, RIGHT_SHOULDER_BLADE_JOINT);
					joints[RIGHT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(85, e_m*10, 0, RIGHT_UPPER_ARM_JOINT);					
					joints[RIGHT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise(e_m*10, e_m*-130, e_m*-40, RIGHT_LOWER_ARM_JOINT);
					joints[RIGHT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise(0, 50, 0, RIGHT_THUMB_BASE_JOINT);					
				}	
			} else if (getGrandDivision() == CONCENTRIC)
			{
				if (getSubDivision() == EXCENTRIC)
				{
					// arms folded tightly on chest; forearms nearly level with shoulders
					// not used
					joints[LEFT_SHOULDER_BLADE_JOINT].localEulerAngles = addPerlinNoise(e_m*10, e_m*5, e_m*-35, LEFT_SHOULDER_BLADE_JOINT);
					joints[LEFT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(-90, e_m*5, e_m*-45, LEFT_UPPER_ARM_JOINT);
					joints[LEFT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise(e_m*-130, e_m*20, 0, LEFT_LOWER_ARM_JOINT);
					joints[LEFT_WRIST_JOINT].localEulerAngles = addPerlinNoise( 0, 0, 0, LEFT_WRIST_JOINT);	
					joints[LEFT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise( 0, -50, 0, LEFT_THUMB_BASE_JOINT);

					joints[RIGHT_SHOULDER_BLADE_JOINT].localEulerAngles = addPerlinNoise(e_m*-10, e_m*-5, e_m*-35, RIGHT_SHOULDER_BLADE_JOINT);
					joints[RIGHT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(90, e_m*-10, e_m*-45, RIGHT_UPPER_ARM_JOINT);
					joints[RIGHT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise(e_m*130, e_m*-20, 0, RIGHT_LOWER_ARM_JOINT);
					joints[RIGHT_WRIST_JOINT].localEulerAngles = addPerlinNoise(0, 0, 0, RIGHT_WRIST_JOINT);	
					joints[RIGHT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise(0, 50, 0, RIGHT_THUMB_BASE_JOINT);					
				} else if (getSubDivision() == NORMAL) 
				{
					// arms crossed on breast
					joints[LEFT_SHOULDER_BLADE_JOINT].localEulerAngles = addPerlinNoise(e_m*10, e_m*5, e_m*-35, LEFT_SHOULDER_BLADE_JOINT);
					joints[LEFT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise(-90, 5, -45, LEFT_UPPER_ARM_JOINT);
					joints[LEFT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise(e_m*-130, e_m*20, 0, LEFT_LOWER_ARM_JOINT);
					joints[LEFT_WRIST_JOINT].localEulerAngles = addPerlinNoise(e_m*-5, e_m*-20, 0, LEFT_WRIST_JOINT);	
					joints[LEFT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise( 0, -50, 0, LEFT_THUMB_BASE_JOINT);

					joints[RIGHT_SHOULDER_BLADE_JOINT].localEulerAngles = addPerlinNoise(e_m*-10, e_m*-5, e_m*-35, RIGHT_SHOULDER_BLADE_JOINT);
					joints[RIGHT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise( 90, -10, -45, RIGHT_UPPER_ARM_JOINT);
					joints[RIGHT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise(e_m*130, e_m*-20, 0, RIGHT_LOWER_ARM_JOINT);
					joints[RIGHT_WRIST_JOINT].localEulerAngles = addPerlinNoise(e_m*5, e_m*20, 0, RIGHT_WRIST_JOINT);	
					joints[RIGHT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise( 0, 50, 0, RIGHT_THUMB_BASE_JOINT);
				} else if (getSubDivision() == CONCENTRIC) 
				{
					// arms hang back of body
					joints[LEFT_SHOULDER_BLADE_JOINT].localEulerAngles = addPerlinNoise(0, 0, e_m*15, LEFT_SHOULDER_BLADE_JOINT);
					joints[LEFT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise( -90, e_m*90, e_m*-45, LEFT_UPPER_ARM_JOINT);
					joints[LEFT_LOWER_ARM_JOINT].localEulerAngles = addPerlinNoise( 0, 0, 0, LEFT_LOWER_ARM_JOINT);
					
					joints[LEFT_WRIST_JOINT].localEulerAngles = addPerlinNoise( 0, 0, 0, LEFT_WRIST_JOINT);	
					joints[LEFT_THUMB_BASE_JOINT].localEulerAngles = addPerlinNoise( 0, -50, 0, LEFT_THUMB_BASE_JOINT);					

					joints[RIGHT_SHOULDER_BLADE_JOINT].localEulerAngles = addPerlinNoise(0, 0, e_m*15, RIGHT_SHOULDER_BLADE_JOINT);
					joints[RIGHT_UPPER_ARM_JOINT].localEulerAngles = addPerlinNoise( 90, e_m*5, e_m*45, RIGHT_UPPER_ARM_JOINT);
				}
				
			}
		}			
	}
			
	class Head:DelsarteRegion {
		public void setDelsarteDivisions(EmotionalStatus emo) 
		{
			switch (emo.emotion)
			{
				case NEUTRAL:	
					setCurrentDivisions(NORMAL, NORMAL);
					break;
				case HAPPINESS:
					setCurrentDivisions(NORMAL, EXCENTRIC);
					break;				
				case PRIDE:
					setCurrentDivisions(EXCENTRIC, EXCENTRIC);
					break;
				case SADNESS:
					setCurrentDivisions(CONCENTRIC, CONCENTRIC);
					break;				
				case FEAR:
					setCurrentDivisions(CONCENTRIC, CONCENTRIC);
					break;				
				case ANGER:
					setCurrentDivisions(EXCENTRIC, NORMAL);
					break;				
				case CONTEMPT:
					setCurrentDivisions(EXCENTRIC, EXCENTRIC);
					break;				
				case SHAME:
					setCurrentDivisions(CONCENTRIC, CONCENTRIC);
					break;				
				case GUILT:
					setCurrentDivisions(CONCENTRIC, CONCENTRIC);
					break;				
				default: 
					Debug.Log("Something went wrong, undefined emotion");
					break;			
			}
		}	
		
//	private const int NECK_JOINT					= 33;
//	private const int HEAD_JOINT					= 34;		
		public void setJoints(EmotionalStatus emo, ref Transform[] joints)
		{	
			// set the emotional multiplier
			float e_m = emo.strength / MAX_STRENGTH;			
						
			if (getGrandDivision() == EXCENTRIC) 
			{
				if (getSubDivision() == EXCENTRIC)
				{
					joints[NECK_JOINT].localEulerAngles = addPerlinNoise(-(e_m*10), 0, -(e_m*20), NECK_JOINT);
				} else if (getSubDivision() == NORMAL) 
				{	
					joints[NECK_JOINT].localEulerAngles = addPerlinNoise(-(e_m*10), 0, 0, NECK_JOINT);
				} else if (getSubDivision() == CONCENTRIC) 
				{
					joints[NECK_JOINT].localEulerAngles = addPerlinNoise(-(e_m*10), 0, 20, NECK_JOINT);
				}
				
			} else if (getGrandDivision() == NORMAL) 
			{
				if (getSubDivision() == EXCENTRIC)
				{
					joints[NECK_JOINT].localEulerAngles = addPerlinNoise(0, 0, -(e_m*20), NECK_JOINT);
				} else if (getSubDivision() == NORMAL) 
				{
					joints[NECK_JOINT].localEulerAngles = addPerlinNoise(0, 0, 0, NECK_JOINT);
				} else if (getSubDivision() == CONCENTRIC) 
				{
					joints[NECK_JOINT].localEulerAngles = addPerlinNoise(0, 0, e_m*20, NECK_JOINT);					
				}	
			} else if (getGrandDivision() == CONCENTRIC)
			{
				if (getSubDivision() == EXCENTRIC)
				{
					joints[NECK_JOINT].localEulerAngles = addPerlinNoise(e_m*10, 0, -(e_m*20), NECK_JOINT);					
				} else if (getSubDivision() == NORMAL) 
				{
					joints[NECK_JOINT].localEulerAngles = addPerlinNoise(e_m*10, 0, 0, NECK_JOINT);
				} else if (getSubDivision() == CONCENTRIC) 
				{					
					joints[NECK_JOINT].localEulerAngles = addPerlinNoise(e_m*10, 0, e_m*20, NECK_JOINT);
				}
			}					
		}	
	}
		
	class Legs:DelsarteRegion {
		public void setDelsarteDivisions(EmotionalStatus emo) 
		{
			switch (emo.emotion)
			{
				case NEUTRAL:	
					setCurrentDivisions(NORMAL, NORMAL);
					break;
				case HAPPINESS:
					setCurrentDivisions(NORMAL, EXCENTRIC);
					break;				
				case PRIDE:
					setCurrentDivisions(EXCENTRIC, CONCENTRIC);
					break;
				case SADNESS:
					setCurrentDivisions(NORMAL, CONCENTRIC);
					break;				
				case FEAR:
					setCurrentDivisions(EXCENTRIC, NORMAL);
					break;				
				case ANGER:
					setCurrentDivisions(EXCENTRIC, EXCENTRIC);
					break;				
				case CONTEMPT:
					setCurrentDivisions(EXCENTRIC, CONCENTRIC);
					break;				
				case SHAME:
					setCurrentDivisions(CONCENTRIC, EXCENTRIC);
					break;				
				case GUILT:
					setCurrentDivisions(CONCENTRIC, CONCENTRIC);
					break;				
				default: 
					Debug.Log("Something went wrong, undefined emotion");
					break;			
			}
		}	
		
//	private const int HIP_JOINT						=  0;		
//	private const int LEFT_UPPER_LEG_JOINT			=  1;
//	private const int LEFT_LOWER_LEG_JOINT			=  2;
//	private const int LEFT_FOOT_JOINT				=  3;
//	private const int LEFT_BALL_JOINT				=  4;
//	private const int LEFT_TOE_JOINT				=  5;
//	private const int RIGHT_UPPER_LEG_JOINT			=  6;
//	private const int RIGHT_LOWER_LEG_JOINT			=  7;
//	private const int RIGHT_FOOT_JOINT				=  8;
//	private const int RIGHT_BALL_JOINT				=  9;
//	private const int RIGHT_TOE_JOINT				= 10;		
		
		// hips and below don't use random noise because people are more stable at their base
		public void setJoints(EmotionalStatus emo, ref Transform[] joints, float facing)
		{	
			// this makes facing matter -- needs to be used throughout the leg options
			float hip_pitch = 90 - 180.0f * facing;
			
			// set the emotional multiplier
			float e_m = emo.strength / MAX_STRENGTH;			
			
			// reset all to avoid left-over pose angles when switching between poses
			for(int i=1;i<=10;i++)
			{
				joints[i].localEulerAngles = new Vector3(0, 0, 0);
			}
			
			if (getGrandDivision() == EXCENTRIC) 
			{
				if (getSubDivision() == EXCENTRIC)
				{
					joints[HIP_JOINT].localEulerAngles = new Vector3( 0, hip_pitch, e_m*30 );											
					joints[RIGHT_UPPER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, -(e_m*45));
					joints[RIGHT_LOWER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, e_m*50);
					
					joints[LEFT_UPPER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, -(e_m*45));
					joints[LEFT_LOWER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, 0);
				} else if (getSubDivision() == NORMAL) 
				{	
					joints[HIP_JOINT].localEulerAngles = new Vector3( 0, hip_pitch, 0 );							

					joints[RIGHT_UPPER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, -(e_m*5));						
					joints[RIGHT_LOWER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, e_m*8);
					
					joints[LEFT_UPPER_LEG_JOINT].localEulerAngles = new Vector3(0, -(e_m*60), -0);
					joints[LEFT_LOWER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, e_m*15);
				} else if (getSubDivision() == CONCENTRIC) 
				{
					joints[HIP_JOINT].localEulerAngles = new Vector3( 0, hip_pitch, -(e_m*5) );				
					joints[RIGHT_UPPER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, -(e_m*10));						
					joints[RIGHT_LOWER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, e_m*15);
					
					joints[LEFT_UPPER_LEG_JOINT].localEulerAngles = new Vector3(0, -(e_m*60), -0);
					joints[LEFT_LOWER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, e_m*15);
				}
				
			} else if (getGrandDivision() == NORMAL) 
			{
				if (getSubDivision() == EXCENTRIC)
				{
					joints[HIP_JOINT].localEulerAngles = new Vector3( 0, hip_pitch, 0 );				
					joints[RIGHT_UPPER_LEG_JOINT].localEulerAngles = new Vector3( 0, 0, e_m*10 );
					joints[RIGHT_LOWER_LEG_JOINT].localEulerAngles = new Vector3( 0, 0, -(e_m*5));
					
					joints[LEFT_UPPER_LEG_JOINT].localEulerAngles = new Vector3(0, -(e_m*20), 0);
					joints[LEFT_LOWER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, e_m*30);	
				} else if (getSubDivision() == NORMAL) 
				{
					joints[HIP_JOINT].localEulerAngles = new Vector3(0, hip_pitch, 0);
					
				} else if (getSubDivision() == CONCENTRIC) 
				{
					joints[HIP_JOINT].localEulerAngles = new Vector3( 0, hip_pitch, -5);		
			
					joints[RIGHT_UPPER_LEG_JOINT].localEulerAngles = new Vector3( 0, 0, -(e_m*10));
					joints[RIGHT_LOWER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, e_m*30);
					
					joints[LEFT_UPPER_LEG_JOINT].localEulerAngles = new Vector3( 0, -(e_m*60), 0);
					joints[LEFT_LOWER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, e_m*15);
				}	
			} else if (getGrandDivision() == CONCENTRIC)
			{
				if (getSubDivision() == EXCENTRIC)
				{
					joints[HIP_JOINT].localEulerAngles = new Vector3( 0, hip_pitch, -(e_m*5));				
					joints[RIGHT_UPPER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, e_m*10);						
					joints[RIGHT_LOWER_LEG_JOINT].localEulerAngles = new Vector3( 0, 0, -(e_m*5));
					
					joints[LEFT_UPPER_LEG_JOINT].localEulerAngles = new Vector3( 0, -(e_m*30), 0);
					joints[LEFT_LOWER_LEG_JOINT].localEulerAngles = new Vector3(0, 0, e_m*50);
				} else if (getSubDivision() == NORMAL) 
				{			
					joints[HIP_JOINT].localEulerAngles = new Vector3( 0, hip_pitch, 0 );				
					joints[RIGHT_UPPER_LEG_JOINT].localEulerAngles = new Vector3(e_m*5, 0, 0 );						
					joints[RIGHT_LOWER_LEG_JOINT].localEulerAngles = new Vector3( 0, 0, 0 );
					joints[RIGHT_FOOT_JOINT].localEulerAngles = new Vector3( 0, e_m*10, 0 );					
					
					joints[LEFT_UPPER_LEG_JOINT].localEulerAngles = new Vector3( -(e_m*5), 0, 0);
					joints[LEFT_LOWER_LEG_JOINT].localEulerAngles = new Vector3( 0, 0, 0 );
					joints[LEFT_FOOT_JOINT].localEulerAngles = new Vector3(0, -(e_m*10), 0);					
				} else if (getSubDivision() == CONCENTRIC) 
				{
					joints[HIP_JOINT].localEulerAngles = new Vector3( 0, hip_pitch, -(e_m*10));				
					joints[RIGHT_UPPER_LEG_JOINT].localEulerAngles = new Vector3( 0, 0, -(e_m*8));
					joints[RIGHT_LOWER_LEG_JOINT].localEulerAngles = new Vector3( 0, 0, e_m*10);
					
					joints[LEFT_UPPER_LEG_JOINT].localEulerAngles = new Vector3( e_m*10, -(e_m*40), e_m*15);
					joints[LEFT_LOWER_LEG_JOINT].localEulerAngles = new Vector3( 0, 0, e_m*15);
				}	
			}
		}	
	}
	
	void Start()
	{
 						
	}//------------------------------------------------------------------------------------------------
 
	//----------------------------------------
	void Update()
	{	
		avatar.setDelsarteDivisions();
		avatar.updateJoints(ref joints);		
	}//--------------------------------------------------------------------------------------------------
	
	//----------------------------------------------------------------
	void OnGUI()
	{
		if(avatarName == "Buddy"){
		  guiRect1 = GUI.Window ( 0, guiRect1, ControlAvatar1, "Buddy" );
		}else if(avatarName == "Molly"){
		  guiRect2 = GUI.Window ( 2, guiRect2, ControlAvatar1, "Molly" );
		}
	}//----------------------------------------------------------------
	
	//----------------------------------------------------------------
	private void ControlAvatar1( int _id )
	{
		onSliderTweak	( avatar ); 
		onReset			( avatar );
			
	}//----------------------------------------------------------------
	
	//----------------------------------------------------------------
	private void onSliderTweak( DelsarteAvatar a )
	{
		int xpos = 100;
		int ypos = 20;
		int yinterval = 20;
		
		// left, top, width, height <= Rect parameter order		
		GUI.Label ( new Rect ( xpos, ypos, 60, 30 ), "Strength" );
//		GUI.Label ( new Rect ( xpos, ypos+yinterval, 60, 30 ), "Sincere?" );
//		GUI.Label ( new Rect ( 10, 80, 60, 30 ), "Objectify Molly?");				
		GUI.Label ( new Rect ( xpos, ypos+2*yinterval, 60, 30 ), "Facing" );

		// HorizontalSlider only takes floats, so cast back to int from temp variable
		float temp_strength; 
		temp_strength = GUI.HorizontalSlider ( new Rect ( 160, ypos+5, 80, 15 ), a.emotional_status.strength, 0, MAX_STRENGTH );
		a.emotional_status.strength = (int) Math.Round(temp_strength);
//		a.emotional_status.sincerity = GUI.Toggle( new Rect ( 160, ypos+20, 15, 15 ), a.emotional_status.sincerity, "Sincerity");
//		a.sideBend		= GUI.HorizontalSlider ( new Rect ( 90, 25, 80, 15 ), a.sideBend,		0, 1 );
//		a.forwardBend	= GUI.HorizontalSlider ( new Rect ( 90, 45, 80, 15 ), a.forwardBend,	0, 1 );	
//		a.emotion 		= need drop down control

		currentSelection = (string) SelectList( emotions, currentSelection, OnCheckboxItemGUI );
		// because constants correspond to index of emotions array, this works
		a.emotional_status.emotion = Array.IndexOf(emotions, currentSelection);
		a.facing		= GUI.HorizontalSlider ( new Rect ( 160, ypos+2*yinterval+5, 80, 15 ), a.facing, 0, 1 );
			
	}//----------------------------------------------------------------

    private bool OnCheckboxItemGUI( object item, bool selected, ICollection list )
    {
    	// set a width for the buttons so they don't obscure the controls to the right
        return GUILayout.Toggle( selected, item.ToString(), GUILayout.Width(100) );
    }	

	//----------------------------------------------------------------
	private void onReset( DelsarteAvatar a )
	{
		if ( GUI.Button ( new Rect ( 180, 160, 50, 20 ), "Reset" ) ) 
		{
			a.forwardBend	= 0.5f;
			a.sideBend		= 0.5f;
			a.facing		= 0.5f;
			// reset emotional status: true neutral
			a.emotional_status.sincerity = true;
			a.emotional_status.strength = 0;
			a.emotional_status.emotion	= 0;
			currentSelection = emotions[0]; // need to ensure GUI checkboxes follow along
		}
			
	}//----------------------------------------------------------------
	
} //---------------------------------------------------
 //----------------- end of class     ----------------
//---------------------------------------------------