Integrating Dual TouchPads into FPSInputController for CharacterMotor

Hello everyone, So I want to build a character controller that would be controlled by Dual TouchPads that are provided in Standard Assets (Mobile). The best thing would be to use CharacterMotor and FPSInputController which takes input from the keyboard and puts it in the CharacterMotor. It would be very nice to take vector direction from the Joystick script and put it in the FPSInputController, or maybe do that vise versa. I've been trying to figure out this character controller for days now, and I just ran out of ideas. Please help me with that, or maybe point out some controllers that would at least move with moving platforms and be controlled by touch screen. Thank you very much in advance!

Here's the script for the FPSInputController:

 private var motor : CharacterMotor;
 
 // Use this for initialization
 function Awake () {
     motor = GetComponent(CharacterMotor);
 }
 
 // Update is called once per frame
 function Update () {
     // Get the input vector from keyboard or analog stick
     var directionVector = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));
     
     if (directionVector != Vector3.zero) {
         // Get the length of the directon vector and then normalize it
         // Dividing by the length is cheaper than normalizing when we already have the length anyway
         var directionLength = directionVector.magnitude;
         directionVector = directionVector / directionLength;
         
         // Make sure the length is no bigger than 1
         directionLength = Mathf.Min(1, directionLength);
         
         // Make the input vector more sensitive towards the extremes and less sensitive in the middle
         // This makes it easier to control slow speeds when using analog sticks
         directionLength = directionLength * directionLength;
         
         // Multiply the normalized direction vector by the modified length
         directionVector = directionVector * directionLength;
     }
     
     // Apply the direction to the CharacterMotor
     motor.inputMoveDirection = transform.rotation * directionVector;
     motor.inputJump = Input.GetButton("Jump");
 }
 
 // Require a character controller to be attached to the same game object
 @script RequireComponent (CharacterMotor)
 @script AddComponentMenu ("Character/FPS Input Controller")

And here's the script for the Joystick.js:

 #pragma strict
 
 @script RequireComponent( GUITexture )
 
 // A simple class for bounding how far the GUITexture will move
 class Boundary 
 {
     var min : Vector2 = Vector2.zero;
     var max : Vector2 = Vector2.zero;
 }
 
 static private var joysticks : Joystick[];                    // A static collection of all joysticks
 static private var enumeratedJoysticks : boolean = false;
 static private var tapTimeDelta : float = 0.3;                // Time allowed between taps
 
 var touchPad : boolean;                                     // Is this a TouchPad?
 var touchZone : Rect;
 var deadZone : Vector2 = Vector2.zero;                        // Control when position is output
 var normalize : boolean = false;                             // Normalize output after the dead-zone?
 var position : Vector2;                                     // [-1, 1] in x,y
 var tapCount : int;                                            // Current tap count
 
 private var lastFingerId = -1;                                // Finger last used for this joystick
 private var tapTimeWindow : float;                            // How much time there is left for a tap to occur
 private var fingerDownPos : Vector2;
 private var fingerDownTime : float;
 private var firstDeltaTime : float = 0.5;
 
 private var gui : GUITexture;                                // Joystick graphic
 private var defaultRect : Rect;                                // Default position / extents of the joystick graphic
 private var guiBoundary : Boundary = Boundary();            // Boundary for joystick graphic
 private var guiTouchOffset : Vector2;                        // Offset to apply to touch input
 private var guiCenter : Vector2;                            // Center of joystick
 
 function Start()
 {
     // Cache this component at startup instead of looking up every frame    
     gui = GetComponent( GUITexture );
     
     // Store the default rect for the gui, so we can snap back to it
     defaultRect = gui.pixelInset;    
     
     defaultRect.x += transform.position.x * Screen.width;// + gui.pixelInset.x; // -  Screen.width * 0.5;
     defaultRect.y += transform.position.y * Screen.height;// - Screen.height * 0.5;
     
     transform.position.x = 0.0;
     transform.position.y = 0.0;
         
     if ( touchPad )
     {
         // If a texture has been assigned, then use the rect ferom the gui as our touchZone
         if ( gui.texture )
             touchZone = defaultRect;
     }
     else
     {                
         // This is an offset for touch input to match with the top left
         // corner of the GUI
         guiTouchOffset.x = defaultRect.width * 0.5;
         guiTouchOffset.y = defaultRect.height * 0.5;
         
         // Cache the center of the GUI, since it doesn't change
         guiCenter.x = defaultRect.x + guiTouchOffset.x;
         guiCenter.y = defaultRect.y + guiTouchOffset.y;
         
         // Let's build the GUI boundary, so we can clamp joystick movement
         guiBoundary.min.x = defaultRect.x - guiTouchOffset.x;
         guiBoundary.max.x = defaultRect.x + guiTouchOffset.x;
         guiBoundary.min.y = defaultRect.y - guiTouchOffset.y;
         guiBoundary.max.y = defaultRect.y + guiTouchOffset.y;
     }
 }
 
 function Disable()
 {
     gameObject.SetActive(false);
     enumeratedJoysticks = false;
 }
 
 function ResetJoystick()
 {
     // Release the finger control and set the joystick back to the default position
     gui.pixelInset = defaultRect;
     lastFingerId = -1;
     position = Vector2.zero;
     fingerDownPos = Vector2.zero;
     
     if ( touchPad )
         gui.color.a = 0.025;    
 }
 
 function IsFingerDown() : boolean
 {
     return (lastFingerId != -1);
 }
     
 function LatchedFinger( fingerId : int )
 {
     // If another joystick has latched this finger, then we must release it
     if ( lastFingerId == fingerId )
         ResetJoystick();
 }
 
 function Update()
 {    
     if ( !enumeratedJoysticks )
     {
         // Collect all joysticks in the game, so we can relay finger latching messages
         joysticks = FindObjectsOfType( Joystick ) as Joystick[];
         enumeratedJoysticks = true;
     }    
         
     var count = Input.touchCount;
     
     // Adjust the tap time window while it still available
     if ( tapTimeWindow > 0 )
         tapTimeWindow -= Time.deltaTime;
     else
         tapCount = 0;
     
     if ( count == 0 )
         ResetJoystick();
     else
     {
         for(var i : int = 0;i < count; i++)
         {
             var touch : Touch = Input.GetTouch(i);            
             var guiTouchPos : Vector2 = touch.position - guiTouchOffset;
     
             var shouldLatchFinger = false;
             if ( touchPad )
             {                
                 if ( touchZone.Contains( touch.position ) )
                     shouldLatchFinger = true;
             }
             else if ( gui.HitTest( touch.position ) )
             {
                 shouldLatchFinger = true;
             }        
     
             // Latch the finger if this is a new touch
             if ( shouldLatchFinger && ( lastFingerId == -1 || lastFingerId != touch.fingerId ) )
             {
                 
                 if ( touchPad )
                 {
                     gui.color.a = 0.15;
                     
                     lastFingerId = touch.fingerId;
                     fingerDownPos = touch.position;
                     fingerDownTime = Time.time;
                 }
                 
                 lastFingerId = touch.fingerId;
                 
                 // Accumulate taps if it is within the time window
                 if ( tapTimeWindow > 0 )
                     tapCount++;
                 else
                 {
                     tapCount = 1;
                     tapTimeWindow = tapTimeDelta;
                 }
                                             
                 // Tell other joysticks we've latched this finger
                 for ( var j : Joystick in joysticks )
                 {
                     if ( j != this )
                         j.LatchedFinger( touch.fingerId );
                 }                        
             }                
     
             if ( lastFingerId == touch.fingerId )
             {    
                 // Override the tap count with what the iPhone SDK reports if it is greater
                 // This is a workaround, since the iPhone SDK does not currently track taps
                 // for multiple touches
                 if ( touch.tapCount > tapCount )
                     tapCount = touch.tapCount;
                 
                 if ( touchPad )
                 {    
                     // For a touchpad, let's just set the position directly based on distance from initial touchdown
                     position.x = Mathf.Clamp( ( touch.position.x - fingerDownPos.x ) / ( touchZone.width / 2 ), -1, 1 );
                     position.y = Mathf.Clamp( ( touch.position.y - fingerDownPos.y ) / ( touchZone.height / 2 ), -1, 1 );
                 }
                 else
                 {                    
                     // Change the location of the joystick graphic to match where the touch is
                     gui.pixelInset.x =  Mathf.Clamp( guiTouchPos.x, guiBoundary.min.x, guiBoundary.max.x );
                     gui.pixelInset.y =  Mathf.Clamp( guiTouchPos.y, guiBoundary.min.y, guiBoundary.max.y );        
                 }
                 
                 if ( touch.phase == TouchPhase.Ended || touch.phase == TouchPhase.Canceled )
                     ResetJoystick();                    
             }            
         }
     }
     
     if ( !touchPad )
     {
         // Get a value between -1 and 1 based on the joystick graphic location
         position.x = ( gui.pixelInset.x + guiTouchOffset.x - guiCenter.x ) / guiTouchOffset.x;
         position.y = ( gui.pixelInset.y + guiTouchOffset.y - guiCenter.y ) / guiTouchOffset.y;
     }
     
     // Adjust for dead zone    
     var absoluteX = Mathf.Abs( position.x );
     var absoluteY = Mathf.Abs( position.y );
     
     if ( absoluteX < deadZone.x )
     {
         // Report the joystick as being at the center if it is within the dead zone
         position.x = 0;
     }
     else if ( normalize )
     {
         // Rescale the output after taking the dead zone into account
         position.x = Mathf.Sign( position.x ) * ( absoluteX - deadZone.x ) / ( 1 - deadZone.x );
     }
         
     if ( absoluteY < deadZone.y )
     {
         // Report the joystick as being at the center if it is within the dead zone
         position.y = 0;
     }
     else if ( normalize )
     {
         // Rescale the output after taking the dead zone into account
         position.y = Mathf.Sign( position.y ) * ( absoluteY - deadZone.y ) / ( 1 - deadZone.y );
     }
 }