This may help .. drop this on something and run.

Play with three fingers on the screen .. it might help demonstrate what the hell is going on!

 function Update()
     {
     
     if ( Input.touches.Length == 1 )
         Debug.Log("    " +Input.touches[0].fingerId);
     
     if ( Input.touches.Length == 2 )
         Debug.Log("    " +Input.touches[0].fingerId
                 +"    " +Input.touches[1].fingerId
                 );
     
     if ( Input.touches.Length == 3 )
         Debug.Log("    " +Input.touches[0].fingerId
                 +"    " +Input.touches[1].fingerId
                 +"    " +Input.touches[2].fingerId
                 );
     
     }

Next step!

Next step you have to process each touch based on it's Unity touchId:

 function Update()
     {
     for ( var t:int=0; t<Input.touches.Length; ++t )
         processATouchPerFingerCodeNumber(
               Input.touches[t], Input.touches[t].fingerId );
     }

So in the next function you have a touch to deal with, and it's Unity code number. Try this code, and extensively play with your iPad. You will really see how it works, it's great.

 function processATouchPerFingerCodeNumber( t:Touch, n:int )
     {
     
     if ( t.phase == TouchPhase.Began )
         {
         Debug.Log("A finger has ARRIVED.  it's arbitrary +"
                     "code number is: " + n);
         return;
         }
     if ( t.phase == TouchPhase.Ended || t.phase == TouchPhase.Canceled )
         {
         Debug.Log("Well that's it. A finger went away .. being "+
                     "arbitrary code number: " + n);
         Debug.Log("(Don't get confused .. the code numbers "+
                     will be resued, perhaps immediately.)");
         return;
         }
     
     // you can also process .Moved and/or .Stationary here
     }

when you have that down, add this clause to the processing function

 if ( t.phase == TouchPhase.Moved )
     {
     Debug.Log("You moved this finger: " + n);
     return;
     }

Now it, carefully moving one finger at a time.

OK so you've got that. Now here's an important point. On many systems those id numbers are just arbitrary, like 343243. (Or you don't even get an id number, it's just a pointer.)

So let's say it was 343243. Now, you have an array of say ten of the image of the red spot - you want to put a red spot under each finger.

Again - the next id number happens to be 343243, and you ave the array of ten.

So what you have to do is, take the "first available" red spot image in the array of red spot images. Let's say it's number 2 currently. So, you have to associate "343243" with YOUR array item 2. (Using a dictionary, lookup, whatever.)

Next time when processATouchPerFingerCodeNumber is called, and the number is "343243" THEN, IN FACT, you have to "look up" what your number it is. (In fact 2 in the example.)

So that's what you normally have to do ...

BUT ......

very conveniently, Unity ensures thas the id code numbers, will run from 0-10. (I"m not sure what the max is on different platforms, but it doesn't matter. YOU should impose a maximum of six, ten or however many fingers you wish to be the maximum.)

Again NORMALLY you MUST do a mapping between the CODE NUMBER (say 424234) and your OWN array (which runs from 0 to 9.)

BUT VERY HAPPILY in the specific Unity case, you don't need to do that. Because Unity guarantees to recycle them, and they always stay below 10, you can and should ...... SIMPLY USE THAT ID NUMBER, as your own array number.

So in short, your code for processATouchPerFingerCodeNumber will look precisely like this.

 function processATouchPerFingerCodeNumber( t:Touch, n:int )
     {
     
     if ( t.phase == TouchPhase.Began )
         {
         // a new finger has arrived!  fortunately WE KNOW it's
         // perfectly OK here in Unity to simply use that same number,
         // "our" array. in most systems, at this stage you would
         // "find an empty slot" and make a note of the mapping from
         // 424341 (or whatever) to our slot. again Unity GUARANTEES
         // to recycle them and always stays low so it is absolutely
         // OK to use it. but it's extremely important to realize
         // you can't normally do this - it's just Unity!!
         
         if ( t >= 7 ) return;
         // we enforce a maximum of seven (say) images, if someone
         // puts more than that many fingers on the screen, they can
         // go to hell
         
         myImages[ t ].showTheImageNow();
         myImages[ t ].positionImageAt( t.position );
         // it's that easy
         return;
         }
     if ( t.phase == TouchPhase.Ended || t.phase == TouchPhase.Canceled )
         {
         myImages[ t ].hideTheImageNow();
         // it's that easy
         return;
         }
     if ( t.phase == TouchPhase.Moved )
         {
         myImages[ t ].positionImageAt( t.position );
         // it's that easy
         // nb as with any touch code, it's always tricky to know
         // how much to move it, you may have to convert from glass
         // to real world, scale, do a raycast, whatever.
         return;
         }
     
     // you can also process .Stationary here if relevant,
     // perhaps spin it or whatever is relevant to you
     }

Hopefully this helps you or someone else reading. Cheers.