Rigidbody

15     void Awake()
16     {
17         m_Animator = GetComponent();
18         m_Body = GetComponent();
19         m_PhotonView = GetComponent();
20     }

10     public void Awake()
11     {
12         if (!photonView.isMine)
13         {
14             Rigidbody attachedRigidbody = GetComponent();
15             if (attachedRigidbody != null)
16             {
17                 attachedRigidbody.isKinematic = true;
18             }
19             else
20             {
21                 Rigidbody2D attachedRigidbody2d = GetComponent();
22                 if (attachedRigidbody2d != null)
23                 {
24                     attachedRigidbody2d.isKinematic = true;
25                 }
26             }
27         }
28     }

20  void Start () {
21   rb2d = GetComponent ();
22   Invoke ("GoBall", 2);
23  }

36  void OnCollisionEnter2D(Collision2D coll) {
37   if (coll.collider.CompareTag ("Player")) {
38    vel.x = rb2d.velocity.x;
39    vel.y = (rb2d.velocity.y / 2.0f) + (coll.collider.attachedRigidbody.velocity.y / 3.0f);
40    rb2d.velocity = vel;
41   }
42  }

14  void Start () {
15   rb2d = GetComponent ();
16  }

145     void DrawSpecificTypeSerializationOptions()
146     {
147         if( m_Target.ObservedComponents.FindAll( item => item != null && item.GetType() == typeof( Transform ) ).Count > 0 ||
148             ( m_Target.observed != null && m_Target.observed.GetType() == typeof( Transform ) ) )
149         {
150             m_Target.onSerializeTransformOption = (OnSerializeTransform)EditorGUILayout.EnumPopup( "Transform Serialization:", m_Target.onSerializeTransformOption );
151
152         }
153         else if( m_Target.ObservedComponents.FindAll( item => item != null && item.GetType() == typeof( Rigidbody ) ).Count > 0 ||
154             ( m_Target.observed != null && m_Target.observed.GetType() == typeof( Rigidbody ) ) ||
155             m_Target.ObservedComponents.FindAll( item => item != null && item.GetType() == typeof( Rigidbody2D ) ).Count > 0 ||
156             ( m_Target.observed != null && m_Target.observed.GetType() == typeof( Rigidbody2D ) ) )
157         {
158             m_Target.onSerializeRigidBodyOption = (OnSerializeRigidBody)EditorGUILayout.EnumPopup( "Rigidbody Serialization:", m_Target.onSerializeRigidBodyOption );
159         }
160     }

162     void DrawSpecificTypeOptions()
163     {
164         if( m_Target.observed != null )
165         {
166             Type type = m_Target.observed.GetType();
167             if( type == typeof( Transform ) )
168             {
169                 m_Target.onSerializeTransformOption = (OnSerializeTransform)EditorGUILayout.EnumPopup( "Serialization:", m_Target.onSerializeTransformOption );
170
171             }
172             else if( type == typeof( Rigidbody ) )
173             {
174                 m_Target.onSerializeRigidBodyOption = (OnSerializeRigidBody)EditorGUILayout.EnumPopup( "Serialization:", m_Target.onSerializeRigidBodyOption );
175
176             }
177         }
178     }

27     void Awake()
28     {
29         m_Body = GetComponent();
30     }

27     void Awake()
28     {
29         m_Body = GetComponent();
30     }

348     internal protected void DeserializeComponent( Component component, PhotonStream stream, PhotonMessageInfo info )
349     {
350         if( component == null )
351         {
352             return;
353         }
354
355         // Use incoming data according to observed type
356         if( component is MonoBehaviour )
357         {
358             ExecuteComponentOnSerialize( component, stream, info );
359         }
360         else if( component is Transform )
361         {
362             Transform trans = (Transform)component;
363
364             switch( onSerializeTransformOption )
365             {
366             case OnSerializeTransform.All:
367                 trans.localPosition = (Vector3)stream.ReceiveNext();
368                 trans.localRotation = (Quaternion)stream.ReceiveNext();
369                 trans.localScale = (Vector3)stream.ReceiveNext();
370                 break;
371             case OnSerializeTransform.OnlyPosition:
372                 trans.localPosition = (Vector3)stream.ReceiveNext();
373                 break;
374             case OnSerializeTransform.OnlyRotation:
375                 trans.localRotation = (Quaternion)stream.ReceiveNext();
376                 break;
377             case OnSerializeTransform.OnlyScale:
378                 trans.localScale = (Vector3)stream.ReceiveNext();
379                 break;
380             case OnSerializeTransform.PositionAndRotation:
381                 trans.localPosition = (Vector3)stream.ReceiveNext();
382                 trans.localRotation = (Quaternion)stream.ReceiveNext();
383                 break;
384             }
385         }
386         else if( component is Rigidbody )
387         {
388             Rigidbody rigidB = (Rigidbody)component;
389
390             switch( onSerializeRigidBodyOption )
391             {
392             case OnSerializeRigidBody.All:
393                 rigidB.velocity = (Vector3)stream.ReceiveNext();
394                 rigidB.angularVelocity = (Vector3)stream.ReceiveNext();
395                 break;
396             case OnSerializeRigidBody.OnlyAngularVelocity:
397                 rigidB.angularVelocity = (Vector3)stream.ReceiveNext();
398                 break;
399             case OnSerializeRigidBody.OnlyVelocity:
400                 rigidB.velocity = (Vector3)stream.ReceiveNext();
401                 break;
402             }
403         }
404         else if( component is Rigidbody2D )
405         {
406             Rigidbody2D rigidB = (Rigidbody2D)component;
407
408             switch( onSerializeRigidBodyOption )
409             {
410             case OnSerializeRigidBody.All:
411                 rigidB.velocity = (Vector2)stream.ReceiveNext();
412                 rigidB.angularVelocity = (float)stream.ReceiveNext();
413                 break;
414             case OnSerializeRigidBody.OnlyAngularVelocity:
415                 rigidB.angularVelocity = (float)stream.ReceiveNext();
416                 break;
417             case OnSerializeRigidBody.OnlyVelocity:
418                 rigidB.velocity = (Vector2)stream.ReceiveNext();
419                 break;
420             }
421         }
422         else
423         {
424             Debug.LogError( "Type of observed is unknown when receiving." );
425         }
426     }