SetBool

89     void UpdateIsRunning()
90     {
91         m_Animator.SetBool( "IsRunning", Mathf.Abs( m_Body.velocity.x ) > 0.1f );
92     }

94     void UpdateIsGrounded()
95     {
96         Vector2 position = new Vector2( transform.position.x, transform.position.y );
97
98         RaycastHit2D hit = Physics2D.Raycast( position, -Vector2.up, 0.1f, 1 << LayerMask.NameToLayer( "Ground" ) );
99
100         m_IsGrounded = hit.collider != null;
101         m_Animator.SetBool( "IsGrounded", m_IsGrounded );
102     }

34     static void OnUpdate()
35     {
36         bool doneBefore = EditorPrefs.GetBool("PunDemosOpenedBefore");
37         if (doneBefore)
38         {
39             EditorApplication.update -= OnUpdate;
40             return;
41         }
42
43         if (String.IsNullOrEmpty(EditorApplication.currentScene) && EditorBuildSettings.scenes.Length == 0)
44         {
45             #if UNITY_4_2 || UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_5_1 || UNITY_5_2
46             if (EditorApplication.isUpdating) return;
47             #endif
48
49             LoadPunDemoHub();
50             SetPunDemoBuildSettings();
51             EditorPrefs.SetBool("PunDemosOpenedBefore", true);
52             Debug.Log("No scene was open. Loaded PUN Demo Hub Scene and added demos to build settings. Ready to go! This auto-setup is now disabled in this Editor.");
53         }
54     }

33     void Update ()
34     {
35         if( m_PhotonView.isMine == false && PhotonNetwork.connected == true )
36         {
37             return;
38         }
39
40         if (animator)
41         {
42             AnimatorStateInfo stateInfo = animator.GetCurrentAnimatorStateInfo(0);
43
44             if (stateInfo.IsName("Base Layer.Run"))
45             {
46                 if (Input.GetButton("Fire1")) animator.SetBool("Jump", true);
47             }
48             else
49             {
50                 animator.SetBool("Jump", false);
51             }
52
53             if(Input.GetButtonDown("Fire2") && animator.layerCount >= 2)
54             {
55                 animator.SetBool("Hi", !animator.GetBool("Hi"));
56             }
57
58
59             float h = Input.GetAxis("Horizontal");
60             float v = Input.GetAxis("Vertical");
61
62             if( v < 0 )
63             {
64                 v = 0;
65             }
66
67             animator.SetFloat( "Speed", h*h+v*v );
68             animator.SetFloat( "Direction", h, DirectionDampTime, Time.deltaTime );
69
70             float direction = animator.GetFloat( "Direction" );
71
72             float targetSpeedModifier = Mathf.Abs( v );
73
74             if( Mathf.Abs( direction ) > 0.2f )
75             {
76                 targetSpeedModifier = TurnSpeedModifier;
77             }
78
79             m_SpeedModifier = Mathf.MoveTowards( m_SpeedModifier, targetSpeedModifier, Time.deltaTime * 25f );
80
81             Vector3 speed = transform.forward * SynchronizedMaxSpeed * m_SpeedModifier;
82             float turnSpeed = direction * SynchronizedTurnSpeed;
83
84             /*float moveDistance = Vector3.Distance( transform.position, m_LastPosition ) / Time.deltaTime;
85
86             if( moveDistance < 4f && turnSpeed == 0f )
87             {
88                 speed = transform.forward * moveDistance;
89             }*/
90
91             //Debug.Log( moveDistance );
92             //Debug.Log( speed + " - " + speed.magnitude + " - " + speedModifier + " - " + h + " - " + v );
93
94             m_TransformView.SetSynchronizedValues( speed, turnSpeed );
95
96             //m_LastPosition = transform.position;
97          }
98     }

275     void DeserializeDataContinuously()
276     {
277         if( m_StreamQueue.HasQueuedObjects() == false )
278         {
279             return;
280         }
281
282         for( int i = 0; i < m_SynchronizeLayers.Count; ++i )
283         {
284             if( m_SynchronizeLayers[ i ].SynchronizeType == SynchronizeType.Continuous )
285             {
286                 m_Animator.SetLayerWeight( m_SynchronizeLayers[ i ].LayerIndex, (float)m_StreamQueue.ReceiveNext() );
287             }
288         }
289
290         for( int i = 0; i < m_SynchronizeParameters.Count; ++i )
291         {
292             SynchronizedParameter parameter = m_SynchronizeParameters[ i ];
293
294             if( parameter.SynchronizeType == SynchronizeType.Continuous )
295             {
296                 switch( parameter.Type )
297                 {
298                 case ParameterType.Bool:
299                     m_Animator.SetBool( parameter.Name, (bool)m_StreamQueue.ReceiveNext() );
300                     break;
301                 case ParameterType.Float:
302                     m_Animator.SetFloat( parameter.Name, (float)m_StreamQueue.ReceiveNext() );
303                     break;
304                 case ParameterType.Int:
305                     m_Animator.SetInteger( parameter.Name, (int)m_StreamQueue.ReceiveNext() );
306                     break;
307                 case ParameterType.Trigger:
308
309                     break;
310                 }
311             }
312         }
313     }

350     void DeserializeDataDiscretly( PhotonStream stream )
351     {
352         for( int i = 0; i < m_SynchronizeLayers.Count; ++i )
353         {
354             if( m_SynchronizeLayers[ i ].SynchronizeType == SynchronizeType.Discrete )
355             {
356                 m_Animator.SetLayerWeight( m_SynchronizeLayers[ i ].LayerIndex, (float)stream.ReceiveNext() );
357             }
358         }
359
360         for( int i = 0; i < m_SynchronizeParameters.Count; ++i )
361         {
362             SynchronizedParameter parameter = m_SynchronizeParameters[ i ];
363
364             if( parameter.SynchronizeType == SynchronizeType.Discrete )
365             {
366                 switch( parameter.Type )
367                 {
368                 case ParameterType.Bool:
369                     if( stream.PeekNext() is bool == false )
370                     {
371                         return;
372                     }
373
374                     m_Animator.SetBool( parameter.Name, (bool)stream.ReceiveNext() );
375                     break;
376                 case ParameterType.Float:
377                     if( stream.PeekNext() is float == false )
378                     {
379                         return;
380                     }
381
382                     m_Animator.SetFloat( parameter.Name, (float)stream.ReceiveNext() );
383                     break;
384                 case ParameterType.Int:
385                     if( stream.PeekNext() is int == false )
386                     {
387                         return;
388                     }
389
390                     m_Animator.SetInteger( parameter.Name, (int)stream.ReceiveNext() );
391                     break;
392                 case ParameterType.Trigger:
393
394                     break;
395                 }
396             }
397         }
398     }

88         {
89             get
90             {
91                 return EditorPrefs.GetBool("VSCode_Debug", false);
92             }
93             set
94             {
95                 EditorPrefs.SetBool("VSCode_Debug", value);
96             }
97         }

106         {
107             get
108             {
109                 return EditorPrefs.GetBool("VSCode_Enabled", false);
110             }
111             set
112             {
113                 // When turning the plugin on, we should remove all the previous project files
114                 if (!Enabled && value)
115                 {
116                     ClearProjectFiles();
117                 }
118                 EditorPrefs.SetBool("VSCode_Enabled", value);
119             }
120         }

122         {
123             get
124             {
125                 return EditorPrefs.GetBool("VSCode_UseUnityDebugger", false);
126             }
127             set
128             {
129                 if ( value != UseUnityDebugger ) {
130
131                     // Set value
132                     EditorPrefs.SetBool("VSCode_UseUnityDebugger", value);
133
134                     // Do not write the launch JSON file because the debugger uses its own
135                     if ( value ) {
136                         WriteLaunchFile = false;
137                     }
138
139                     // Update launch file
140                     UpdateLaunchFile();
141                 }
142             }
143         }

149         {
150             get
151             {
152                 return EditorPrefs.GetBool("VSCode_AutoOpenEnabled", false);
153             }
154             set
155             {
156                 EditorPrefs.SetBool("VSCode_AutoOpenEnabled", value);
157             }
158         }