Unity Networking. Player flickers.

Hey. I'm currently trying to get rid of a little problem i have with my Multiplayer FPS. When i use only NetworkViews to synchronize the position of the Player between all connected players, the Player-Gameobjects of the other players kind of flicker when they move. That's why i added the NetworkInterpolatedTransfom Script from the Networking example to every Gameobject which has a NetworkView attached to it. When a game started i execute this code snippet in another script:

 function Start () {
         if(!networkView.isMine){
         var interpscript : NetworkInterpolatedTransform = GetComponent("NetworkInterpolatedTransform");
         interpscript.enabled = true;
         transform.networkView.observed = interpscript;
 }
 }

With this code i activate the NetworkInterpolatedTransform-Script and set the observed value of the networkview to this script on every gameobject i added this Script before.

The result of this can be seen in this Web Demo: http://dl.dropbox.com/u/83937500/WebPlayerBuild.html

(How to play:Open it in 2 BrowserWindows, type in a Name, click on advanced, click on start hosting a server, then test , then Start Server. In the other window just click on advanced and your server should show up in the Join a game via the list window)(Btw. Models/Animation/... are just for testing)

As you can hopefully see: There is a some type of flickering in the direction where the player moves. The Player himself is not flickering at all.

Now my question is: Where does this problem possible comes from and how can i solve it if someone knows how?

If you don't know the NetworkInterpolatedTransform-Script and need to see it to answer the question i can post it here.

Thanks in advance, ExTheSea.

PS: Here is the NetworkInterpolatedTransform.cs because i saw that the Networking example isn't available anymore for some reason:

 using UnityEngine;
 using System.Collections;
 
 public class NetworkInterpolatedTransform : MonoBehaviour {
     
     public double interpolationBackTime = 0.1; 
     
     internal struct  State
     {
         internal double timestamp;
         internal Vector3 pos;
         internal Quaternion rot;
     }
 
     // We store twenty states with "playback" information
     State[] m_BufferedState = new State[20];
     // Keep track of what slots are used
     int m_TimestampCount;
     
     void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
     {
         // Always send transform (depending on reliability of the network view)
         if (stream.isWriting)
         {
             Vector3 pos = transform.localPosition;
             Quaternion rot = transform.localRotation;
             stream.Serialize(ref pos);
             stream.Serialize(ref rot);
         }
         // When receiving, buffer the information
         else
         {
             // Receive latest state information
             Vector3 pos = Vector3.zero;
             Quaternion rot = Quaternion.identity;
             stream.Serialize(ref pos);
             stream.Serialize(ref rot);
             
             // Shift buffer contents, oldest data erased, 18 becomes 19, ... , 0 becomes 1
             for (int i=m_BufferedState.Length-1;i>=1;i--)
             {
                 m_BufferedState[i] = m_BufferedState[i-1];
             }
             
             // Save currect received state as 0 in the buffer, safe to overwrite after shifting
             State state;
             state.timestamp = info.timestamp;
             state.pos = pos;
             state.rot = rot;
             m_BufferedState[0] = state;
             
             // Increment state count but never exceed buffer size
             m_TimestampCount = Mathf.Min(m_TimestampCount + 1, m_BufferedState.Length);
 
             // Check integrity, lowest numbered state in the buffer is newest and so on
             for (int i=0;i<m_TimestampCount-1;i++)
             {
                 if (m_BufferedState[i].timestamp < m_BufferedState[i+1].timestamp)
                     Debug.Log("State inconsistent");
             }
             
             //Debug.Log("stamp: " + info.timestamp + "my time: " + Network.time + "delta: " + (Network.time - info.timestamp));
         }
     }
     
     // This only runs where the component is enabled, which is only on remote peers (server/clients)
     void Update () {
         double currentTime = Network.time;
         double interpolationTime = currentTime - interpolationBackTime;
         // We have a window of interpolationBackTime where we basically play 
         // By having interpolationBackTime the average ping, you will usually use interpolation.
         // And only if no more data arrives we will use extrapolation
         
         // Use interpolation
         // Check if latest state exceeds interpolation time, if this is the case then
         // it is too old and extrapolation should be used
         if (m_BufferedState[0].timestamp > interpolationTime)
         {
             for (int i=0;i<m_TimestampCount;i++)
             {
                 // Find the state which matches the interpolation time (time+0.1) or use last state
                 if (m_BufferedState[i].timestamp <= interpolationTime || i == m_TimestampCount-1)
                 {
                     // The state one slot newer (<100ms) than the best playback state
                     State rhs = m_BufferedState[Mathf.Max(i-1, 0)];
                     // The best playback state (closest to 100 ms old (default time))
                     State lhs = m_BufferedState[i];
                     
                     // Use the time between the two slots to determine if interpolation is necessary
                     double length = rhs.timestamp - lhs.timestamp;
                     float t = 0.0F;
                     // As the time difference gets closer to 100 ms t gets closer to 1 in 
                     // which case rhs is only used
                     if (length > 0.0001)
                         t = (float)((interpolationTime - lhs.timestamp) / length);
                     
                     // if t=0 => lhs is used directly
                     transform.localPosition = Vector3.Lerp(lhs.pos, rhs.pos, t);
                     transform.localRotation = Quaternion.Slerp(lhs.rot, rhs.rot, t);
                     return;
                 }
             }
         }
         // Use extrapolation. Here we do something really simple and just repeat the last
         // received state. You can do clever stuff with predicting what should happen.
         else
         {
             State latest = m_BufferedState[0];
             
             transform.localPosition = latest.pos;
             transform.localRotation = latest.rot;
         }
     }
 }