Rigidbody2D

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  }

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     }

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     }

428     internal protected void SerializeComponent( Component component, PhotonStream stream, PhotonMessageInfo info )
429     {
430         if( component == null )
431         {
432             return;
433         }
434
435         if( component is MonoBehaviour )
436         {
437             ExecuteComponentOnSerialize( component, stream, info );
438         }
439         else if( component is Transform )
440         {
441             Transform trans = (Transform)component;
442
443             switch( onSerializeTransformOption )
444             {
445             case OnSerializeTransform.All:
446                 stream.SendNext( trans.localPosition );
447                 stream.SendNext( trans.localRotation );
448                 stream.SendNext( trans.localScale );
449                 break;
450             case OnSerializeTransform.OnlyPosition:
451                 stream.SendNext( trans.localPosition );
452                 break;
453             case OnSerializeTransform.OnlyRotation:
454                 stream.SendNext( trans.localRotation );
455                 break;
456             case OnSerializeTransform.OnlyScale:
457                 stream.SendNext( trans.localScale );
458                 break;
459             case OnSerializeTransform.PositionAndRotation:
460                 stream.SendNext( trans.localPosition );
461                 stream.SendNext( trans.localRotation );
462                 break;
463             }
464         }
465         else if( component is Rigidbody )
466         {
467             Rigidbody rigidB = (Rigidbody)component;
468
469             switch( onSerializeRigidBodyOption )
470             {
471             case OnSerializeRigidBody.All:
472                 stream.SendNext( rigidB.velocity );
473                 stream.SendNext( rigidB.angularVelocity );
474                 break;
475             case OnSerializeRigidBody.OnlyAngularVelocity:
476                 stream.SendNext( rigidB.angularVelocity );
477                 break;
478             case OnSerializeRigidBody.OnlyVelocity:
479                 stream.SendNext( rigidB.velocity );
480                 break;
481             }
482         }
483         else if( component is Rigidbody2D )
484         {
485             Rigidbody2D rigidB = (Rigidbody2D)component;
486
487             switch( onSerializeRigidBodyOption )
488             {
489             case OnSerializeRigidBody.All:
490                 stream.SendNext( rigidB.velocity );
491                 stream.SendNext( rigidB.angularVelocity );
492                 break;
493             case OnSerializeRigidBody.OnlyAngularVelocity:
494                 stream.SendNext( rigidB.angularVelocity );
495                 break;
496             case OnSerializeRigidBody.OnlyVelocity:
497                 stream.SendNext( rigidB.velocity );
498                 break;
499             }
500         }
501         else
502         {
503             Debug.LogError( "Observed type is not serializable: " + component.GetType() );
504         }
505     }

26     public void Start()
27     {
28         //enabled = photonView.isMine;
29         this.isSprite = (GetComponent() != null);
30
31         this.body2d = GetComponent();
32         this.body = GetComponent();
33     }

33  void Start () {
34   MakeInstance ();
35   rigidbody = GetComponent ();
36   collider = GetComponent ();
37
38   jumpTimeCounter = jumpTime;
39   speedCount = speedIncrease;
40
41   stopJumping = true;
42  }