Integer

61     public void OnGUI()
62     {
63         GUI.skin = Skin;
64
65         string[] synchronizeTypeContent = new string[] { "Disabled", "Discrete", "Continuous" };
66
67         GUILayout.BeginArea( new Rect( Screen.width - 200 * m_FoundPlayerSlideIn - 400 * m_SlideIn, 0, 600, Screen.height ), GUI.skin.box );
68         {
69             GUILayout.Label( "Mecanim Demo", GUI.skin.customStyles[ 0 ] );
70
71             GUI.color = Color.white;
72             string label = "Settings";
73
74             if( m_IsOpen == true )
75             {
76                 label = "Close";
77             }
78
79             if( GUILayout.Button( label, GUILayout.Width( 110 ) ) )
80             {
81                 m_IsOpen = !m_IsOpen;
82             }
83
84             string parameters = "";
85
86             if( m_AnimatorView != null )
87             {
88                 parameters += "Send Values:\n";
89
90                 for( int i = 0; i < m_AnimatorView.GetSynchronizedParameters().Count; ++i )
91                 {
92                     PhotonAnimatorView.SynchronizedParameter parameter = m_AnimatorView.GetSynchronizedParameters()[ i ];
93
94                     try
95                     {
96                         switch( parameter.Type )
97                         {
98                         case PhotonAnimatorView.ParameterType.Bool:
99                             parameters += parameter.Name + " (" + ( m_AnimatorView.GetComponent().GetBool( parameter.Name ) ? "True" : "False" ) + ")\n";
100                             break;
101                         case PhotonAnimatorView.ParameterType.Int:
102                             parameters += parameter.Name + " (" + m_AnimatorView.GetComponent().GetInteger( parameter.Name ) + ")\n";
103                             break;
104                         case PhotonAnimatorView.ParameterType.Float:
105                             parameters += parameter.Name + " (" + m_AnimatorView.GetComponent().GetFloat( parameter.Name ).ToString( "0.00" ) + ")\n";
106                             break;
107                         }
108                     }
109                     catch
110                     {
111                         Debug.Log( "derrrr for " + parameter.Name );
112                     }
113                 }
114             }
115
116             if( m_RemoteAnimator != null )
117             {
118                 parameters += "\nReceived Values:\n";
119
120                 for( int i = 0; i < m_AnimatorView.GetSynchronizedParameters().Count; ++i )
121                 {
122                     PhotonAnimatorView.SynchronizedParameter parameter = m_AnimatorView.GetSynchronizedParameters()[ i ];
123
124                     try
125                     {
126                         switch( parameter.Type )
127                         {
128                         case PhotonAnimatorView.ParameterType.Bool:
129                             parameters += parameter.Name + " (" + ( m_RemoteAnimator.GetBool( parameter.Name ) ? "True" : "False" ) + ")\n";
130                             break;
131                         case PhotonAnimatorView.ParameterType.Int:
132                             parameters += parameter.Name + " (" + m_RemoteAnimator.GetInteger( parameter.Name ) + ")\n";
133                             break;
134                         case PhotonAnimatorView.ParameterType.Float:
135                             parameters += parameter.Name + " (" + m_RemoteAnimator.GetFloat( parameter.Name ).ToString( "0.00" ) + ")\n";
136                             break;
137                         }
138                     }
139                     catch
140                     {
141                         Debug.Log( "derrrr for " + parameter.Name );
142                     }
143                 }
144             }
145
146             GUIStyle style = new GUIStyle( GUI.skin.label );
147             style.alignment = TextAnchor.UpperLeft;
148
149             GUI.color = new Color( 1f, 1f, 1f, 1 - m_SlideIn );
150             GUI.Label( new Rect( 10, 100, 600, Screen.height ), parameters, style );
151
152             if( m_AnimatorView != null )
153             {
154                 GUI.color = new Color( 1f, 1f, 1f, m_SlideIn );
155
156                 GUILayout.Space( 20 );
157                 GUILayout.Label( "Synchronize Parameters" );
158
159                 for( int i = 0; i < m_AnimatorView.GetSynchronizedParameters().Count; ++i )
160                 {
161                     GUILayout.BeginHorizontal();
162                     {
163                         PhotonAnimatorView.SynchronizedParameter parameter = m_AnimatorView.GetSynchronizedParameters()[ i ];
164
165                         GUILayout.Label( parameter.Name, GUILayout.Width( 100 ), GUILayout.Height( 36 ) );
166
167                         int selectedValue = (int)parameter.SynchronizeType;
168                         int newValue = GUILayout.Toolbar( selectedValue, synchronizeTypeContent );
169
170                         if( newValue != selectedValue )
171                         {
172                             m_AnimatorView.SetParameterSynchronized( parameter.Name, parameter.Type, (PhotonAnimatorView.SynchronizeType)newValue );
173                         }
174                     }
175                     GUILayout.EndHorizontal();
176                 }
177             }
178         }
179         GUILayout.EndArea();
180     }

234     void SerializeDataContinuously()
235     {
236         if( m_Animator == null )
237         {
238             return;
239         }
240
241         for( int i = 0; i < m_SynchronizeLayers.Count; ++i )
242         {
243             if( m_SynchronizeLayers[ i ].SynchronizeType == SynchronizeType.Continuous )
244             {
245                 m_StreamQueue.SendNext( m_Animator.GetLayerWeight( m_SynchronizeLayers[ i ].LayerIndex ) );
246             }
247         }
248
249         for( int i = 0; i < m_SynchronizeParameters.Count; ++i )
250         {
251             SynchronizedParameter parameter = m_SynchronizeParameters[ i ];
252
253             if( parameter.SynchronizeType == SynchronizeType.Continuous )
254             {
255
256                 switch( parameter.Type )
257                 {
258                 case ParameterType.Bool:
259                     m_StreamQueue.SendNext( m_Animator.GetBool( parameter.Name ) );
260                     break;
261                 case ParameterType.Float:
262                     m_StreamQueue.SendNext( m_Animator.GetFloat( parameter.Name ) );
263                     break;
264                 case ParameterType.Int:
265                     m_StreamQueue.SendNext( m_Animator.GetInteger( parameter.Name ) );
266                     break;
267                 case ParameterType.Trigger:
268
269                     break;
270                 }
271             }
272         }
273     }

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     }

315     void SerializeDataDiscretly( PhotonStream stream )
316     {
317         for( int i = 0; i < m_SynchronizeLayers.Count; ++i )
318         {
319             if( m_SynchronizeLayers[ i ].SynchronizeType == SynchronizeType.Discrete )
320             {
321                 stream.SendNext( m_Animator.GetLayerWeight( m_SynchronizeLayers[ i ].LayerIndex ) );
322             }
323         }
324
325         for( int i = 0; i < m_SynchronizeParameters.Count; ++i )
326         {
327             SynchronizedParameter parameter = m_SynchronizeParameters[ i ];
328
329             if( parameter.SynchronizeType == SynchronizeType.Discrete )
330             {
331                 switch( parameter.Type )
332                 {
333                 case ParameterType.Bool:
334                     stream.SendNext( m_Animator.GetBool( parameter.Name ) );
335                     break;
336                 case ParameterType.Float:
337                     stream.SendNext( m_Animator.GetFloat( parameter.Name ) );
338                     break;
339                 case ParameterType.Int:
340                     stream.SendNext( m_Animator.GetInteger( parameter.Name ) );
341                     break;
342                 case ParameterType.Trigger:
343
344                     break;
345                 }
346             }
347         }
348     }

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     }

73     void MovePlayer(float playerSpeed)
74     {
75         rb.velocity = new Vector2(playerSpeed, rb.velocity.y);
76
77         if (playerSpeed < 0)
78             sr.flipX = true;
79         else if (playerSpeed > 0)
80             sr.flipX = false;
81
82         if (!isJumping)
83             anim.SetInteger("State", 1);
84     }

86     void StopMoving()
87     {
88         rb.velocity = new Vector2(0, rb.velocity.y);
89
90         if (!isJumping)
91             anim.SetInteger("State", 0);
92     }

94     void ShowFalling()
95     {
96         if (rb.velocity.y < 0)
97         {
98             anim.SetInteger("State", 3);
99         }
100     }

102     void Jump()
103     {
104         if (isGrounded)
105         {
106             isJumping = true;
107             rb.AddForce(new Vector2(0, jumpSpeed)); // simply make the player jump in the y axis or upwards
108             anim.SetInteger("State", 2);
109
110             Invoke("EnableDoubleJump", delayForDoubleJump);
111         }
112
113         if (canDoubleJump && !isGrounded)
114         {
115             rb.velocity = Vector2.zero;
116             rb.AddForce(new Vector2(0, jumpSpeed)); // simply make the player jump in the y axis or upwards
117             anim.SetInteger("State", 2);
118
119             canDoubleJump = false;
120         }
121     }

45         public static bool TryGetInt(this XmlNode node, string key, out int value)
46         {
47             value = default(int);
48             var attr = node.Attributes[key];
49             bool parsed = false;
50             if (attr != null)
51             {
52                 parsed = int.TryParse(attr.Value, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out value);
53             }
54
55             return parsed;
56         }