Lock

94     void Apply( Transform dummyTarget, Vector3 dummyCenter )
95     {
96         // Early out if we don't have a target
97         if( !controller )
98             return;
99
100         Vector3 targetCenter = _target.position + centerOffset;
101         Vector3 targetHead = _target.position + headOffset;
102
103         // DebugDrawStuff();
104
105         // Calculate the current & target rotation angles
106         float originalTargetAngle = _target.eulerAngles.y;
107         float currentAngle = cameraTransform.eulerAngles.y;
108
109         // Adjust real target angle when camera is locked
110         float targetAngle = originalTargetAngle;
111
112         // When pressing Fire2 (alt) the camera will snap to the target direction real quick.
113         // It will stop snapping when it reaches the target
114         if( Input.GetButton( "Fire2" ) )
115             snap = true;
116
117         if( snap )
118         {
119             // We are close to the target, so we can stop snapping now!
120             if( AngleDistance( currentAngle, originalTargetAngle ) < 3.0f )
121                 snap = false;
122
123             currentAngle = Mathf.SmoothDampAngle( currentAngle, targetAngle, ref angleVelocity, snapSmoothLag, snapMaxSpeed );
124         }
125         // Normal camera motion
126         else
127         {
128             if( controller.GetLockCameraTimer() < lockCameraTimeout )
129             {
130                 targetAngle = currentAngle;
131             }
132
133             // Lock the camera when moving backwards!
134             // * It is really confusing to do 180 degree spins when turning around.
135             if( AngleDistance( currentAngle, targetAngle ) > 160 && controller.IsMovingBackwards() )
136                 targetAngle += 180;
137
138             currentAngle = Mathf.SmoothDampAngle( currentAngle, targetAngle, ref angleVelocity, angularSmoothLag, angularMaxSpeed );
139         }
140
141
142         // When jumping don't move camera upwards but only down!
143         if( controller.IsJumping() )
144         {
145             // We'd be moving the camera upwards, do that only if it's really high
146             float newTargetHeight = targetCenter.y + height;
147             if( newTargetHeight < targetHeight || newTargetHeight - targetHeight > 5 )
148                 targetHeight = targetCenter.y + height;
149         }
150         // When walking always update the target height
151         else
152         {
153             targetHeight = targetCenter.y + height;
154         }
155
156         // Damp the height
157         float currentHeight = cameraTransform.position.y;
158         currentHeight = Mathf.SmoothDamp( currentHeight, targetHeight, ref heightVelocity, heightSmoothLag );
159
160         // Convert the angle into a rotation, by which we then reposition the camera
161         Quaternion currentRotation = Quaternion.Euler( 0, currentAngle, 0 );
162
163         // Set the position of the camera on the x-z plane to:
164         // distance meters behind the target
165         cameraTransform.position = targetCenter;
166         cameraTransform.position += currentRotation * Vector3.back * distance;
167
168         // Set the height of the camera
169         cameraTransform.position = new Vector3( cameraTransform.position.x, currentHeight, cameraTransform.position.z );
170
171         // Always look at the target
172         SetUpRotation( targetCenter, targetHead );
173     }

308     void UpdateSmoothedMovementDirection()
309     {
310         Transform cameraTransform = Camera.main.transform;
311         bool grounded = IsGrounded();
312
313         // Forward vector relative to the camera along the x-z plane
314         Vector3 forward = cameraTransform.TransformDirection(Vector3.forward);
315         forward.y = 0;
316         forward = forward.normalized;
317
318         // Right vector relative to the camera
319         // Always orthogonal to the forward vector
320         Vector3 right = new Vector3(forward.z, 0, -forward.x);
321
322         float v = Input.GetAxisRaw("Vertical");
323         float h = Input.GetAxisRaw("Horizontal");
324
325         // Are we moving backwards or looking backwards
326         if (v < -0.2f)
327             movingBack = true;
328         else
329             movingBack = false;
330
331         bool wasMoving = isMoving;
332         isMoving = Mathf.Abs(h) > 0.1f || Mathf.Abs(v) > 0.1f;
333
334         // Target direction relative to the camera
335         Vector3 targetDirection = h * right + v * forward;
336         // Debug.Log("targetDirection " + targetDirection);
337
338         // Grounded controls
339         if (grounded)
340         {
341             // Lock camera for short period when transitioning moving & standing still
342             lockCameraTimer += Time.deltaTime;
343             if (isMoving != wasMoving)
344                 lockCameraTimer = 0.0f;
345
346             // We store speed and direction seperately,
347             // so that when the character stands still we still have a valid forward direction
348             // moveDirection is always normalized, and we only update it if there is user input.
349             if (targetDirection != Vector3.zero)
350             {
351                 // If we are really slow, just snap to the target direction
352                 if (moveSpeed < walkSpeed * 0.9f && grounded)
353                 {
354                     moveDirection = targetDirection.normalized;
355                 }
356                 // Otherwise smoothly turn towards it
357                 else
358                 {
359                     moveDirection = Vector3.RotateTowards(moveDirection, targetDirection, rotateSpeed * Mathf.Deg2Rad * Time.deltaTime, 1000);
360
361                     moveDirection = moveDirection.normalized;
362                 }
363             }
364
365             // Smooth the speed based on the current target direction
366             float curSmooth = speedSmoothing * Time.deltaTime;
367
368             // Choose target speed
369             //* We want to support analog input but make sure you cant walk faster diagonally than just forward or sideways
370             float targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0f);
371
372             _characterState = PickupCharacterState.Idle;
373
374             // Pick speed modifier
375             if ((Input.GetKey(KeyCode.LeftShift) | Input.GetKey(KeyCode.RightShift)) && isMoving)
376             {
377                 targetSpeed *= runSpeed;
378                 _characterState = PickupCharacterState.Running;
379             }
380             else if (Time.time - trotAfterSeconds > walkTimeStart)
381             {
382                 targetSpeed *= trotSpeed;
383                 _characterState = PickupCharacterState.Trotting;
384             }
385             else if (isMoving)
386             {
387                 targetSpeed *= walkSpeed;
388                 _characterState = PickupCharacterState.Walking;
389             }
390
391             moveSpeed = Mathf.Lerp(moveSpeed, targetSpeed, curSmooth);
392
393             // Reset walk time start when we slow down
394             if (moveSpeed < walkSpeed * 0.3f)
395                 walkTimeStart = Time.time;
396         }
397         // In air controls
398         else
399         {
400             // Lock camera while in air
401             if (jumping)
402                 lockCameraTimer = 0.0f;
403
404             if (isMoving)
405                 inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration;
406         }
407     }

86     void Apply( Transform dummyTarget, Vector3 dummyCenter )
87     {
88         // Early out if we don't have a target
89         if( !controller )
90             return;
91
92         Vector3 targetCenter = _target.position + centerOffset;
93         Vector3 targetHead = _target.position + headOffset;
94
95         // DebugDrawStuff();
96
97         // Calculate the current & target rotation angles
98         float originalTargetAngle = _target.eulerAngles.y;
99         float currentAngle = cameraTransform.eulerAngles.y;
100
101         // Adjust real target angle when camera is locked
102         float targetAngle = originalTargetAngle;
103
104         // When pressing Fire2 (alt) the camera will snap to the target direction real quick.
105         // It will stop snapping when it reaches the target
106         if( Input.GetButton( "Fire2" ) )
107             snap = true;
108
109         if( snap )
110         {
111             // We are close to the target, so we can stop snapping now!
112             if( AngleDistance( currentAngle, originalTargetAngle ) < 3.0f )
113                 snap = false;
114
115             currentAngle = Mathf.SmoothDampAngle( currentAngle, targetAngle, ref angleVelocity, snapSmoothLag, snapMaxSpeed );
116         }
117         // Normal camera motion
118         else
119         {
120             if( controller.GetLockCameraTimer() < lockCameraTimeout )
121             {
122                 targetAngle = currentAngle;
123             }
124
125             // Lock the camera when moving backwards!
126             // * It is really confusing to do 180 degree spins when turning around.
127             if( AngleDistance( currentAngle, targetAngle ) > 160 && controller.IsMovingBackwards() )
128                 targetAngle += 180;
129
130             currentAngle = Mathf.SmoothDampAngle( currentAngle, targetAngle, ref angleVelocity, angularSmoothLag, angularMaxSpeed );
131         }
132
133
134         // When jumping don't move camera upwards but only down!
135         if( controller.IsJumping() )
136         {
137             // We'd be moving the camera upwards, do that only if it's really high
138             float newTargetHeight = targetCenter.y + height;
139             if( newTargetHeight < targetHeight || newTargetHeight - targetHeight > 5 )
140                 targetHeight = targetCenter.y + height;
141         }
142         // When walking always update the target height
143         else
144         {
145             targetHeight = targetCenter.y + height;
146         }
147
148         // Damp the height
149         float currentHeight = cameraTransform.position.y;
150         currentHeight = Mathf.SmoothDamp( currentHeight, targetHeight, ref heightVelocity, heightSmoothLag );
151
152         // Convert the angle into a rotation, by which we then reposition the camera
153         Quaternion currentRotation = Quaternion.Euler( 0, currentAngle, 0 );
154
155         // Set the position of the camera on the x-z plane to:
156         // distance meters behind the target
157         cameraTransform.position = targetCenter;
158         cameraTransform.position += currentRotation * Vector3.back * distance;
159
160         // Set the height of the camera
161         cameraTransform.position = new Vector3( cameraTransform.position.x, currentHeight, cameraTransform.position.z );
162
163         // Always look at the target
164         SetUpRotation( targetCenter, targetHead );
165     }

131     void UpdateSmoothedMovementDirection()
132     {
133         Transform cameraTransform = Camera.main.transform;
134         bool grounded = IsGrounded();
135
136         // Forward vector relative to the camera along the x-z plane
137         Vector3 forward = cameraTransform.TransformDirection(Vector3.forward);
138         forward.y = 0;
139         forward = forward.normalized;
140
141         // Right vector relative to the camera
142         // Always orthogonal to the forward vector
143         Vector3 right = new Vector3(forward.z, 0, -forward.x);
144
145         float v = Input.GetAxisRaw("Vertical");
146         float h = Input.GetAxisRaw("Horizontal");
147
148         // Are we moving backwards or looking backwards
149         if (v < -0.2f)
150             movingBack = true;
151         else
152             movingBack = false;
153
154         bool wasMoving = isMoving;
155         isMoving = Mathf.Abs(h) > 0.1f || Mathf.Abs(v) > 0.1f;
156
157         // Target direction relative to the camera
158         Vector3 targetDirection = h * right + v * forward;
159
160         // Grounded controls
161         if (grounded)
162         {
163             // Lock camera for short period when transitioning moving & standing still
164             lockCameraTimer += Time.deltaTime;
165             if (isMoving != wasMoving)
166                 lockCameraTimer = 0.0f;
167
168             // We store speed and direction seperately,
169             // so that when the character stands still we still have a valid forward direction
170             // moveDirection is always normalized, and we only update it if there is user input.
171             if (targetDirection != Vector3.zero)
172             {
173                 // If we are really slow, just snap to the target direction
174                 if (moveSpeed < walkSpeed * 0.9f && grounded)
175                 {
176                     moveDirection = targetDirection.normalized;
177                 }
178                 // Otherwise smoothly turn towards it
179                 else
180                 {
181                     moveDirection = Vector3.RotateTowards(moveDirection, targetDirection, rotateSpeed * Mathf.Deg2Rad * Time.deltaTime, 1000);
182
183                     moveDirection = moveDirection.normalized;
184                 }
185             }
186
187             // Smooth the speed based on the current target direction
188             float curSmooth = speedSmoothing * Time.deltaTime;
189
190             // Choose target speed
191             //* We want to support analog input but make sure you cant walk faster diagonally than just forward or sideways
192             float targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0f);
193
194             _characterState = CharacterState.Idle;
195
196             // Pick speed modifier
197             if (Input.GetKey(KeyCode.LeftShift) | Input.GetKey(KeyCode.RightShift))
198             {
199                 targetSpeed *= runSpeed;
200                 _characterState = CharacterState.Running;
201             }
202             else if (Time.time - trotAfterSeconds > walkTimeStart)
203             {
204                 targetSpeed *= trotSpeed;
205                 _characterState = CharacterState.Trotting;
206             }
207             else
208             {
209                 targetSpeed *= walkSpeed;
210                 _characterState = CharacterState.Walking;
211             }
212
213             moveSpeed = Mathf.Lerp(moveSpeed, targetSpeed, curSmooth);
214
215             // Reset walk time start when we slow down
216             if (moveSpeed < walkSpeed * 0.3f)
217                 walkTimeStart = Time.time;
218         }
219         // In air controls
220         else
221         {
222             // Lock camera while in air
223             if (jumping)
224                 lockCameraTimer = 0.0f;
225
226             if (isMoving)
227                 inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration;
228         }
229
230
231
232     }

451     public float GetLockCameraTimer()
452     {
453         return lockCameraTimer;
454     }

17     public override void OnInspectorGUI()
18     {
19         ServerSettings settings = (ServerSettings)this.target;
20
21         #if UNITY_3_5
22         EditorGUIUtility.LookLikeInspector();
23         #endif
24
25
26         settings.HostType = (ServerSettings.HostingOption)EditorGUILayout.EnumPopup("Hosting", settings.HostType);
27         EditorGUI.indentLevel = 1;
28
29         switch (settings.HostType)
30         {
31             case ServerSettings.HostingOption.BestRegion:
32             case ServerSettings.HostingOption.PhotonCloud:
33                 if (settings.HostType == ServerSettings.HostingOption.PhotonCloud)
34                     settings.PreferredRegion = (CloudRegionCode)EditorGUILayout.EnumPopup("Region", settings.PreferredRegion);
35                 settings.AppID = EditorGUILayout.TextField("AppId", settings.AppID);
36                 settings.Protocol = (ConnectionProtocol)EditorGUILayout.EnumPopup("Protocol", settings.Protocol);
37
38                 if (string.IsNullOrEmpty(settings.AppID) || settings.AppID.Equals("master"))
39                 {
40                     EditorGUILayout.HelpBox("The Photon Cloud needs an AppId (GUID) set.\nYou can find it online in your Dashboard.", MessageType.Warning);
41                 }
42                 break;
43
44             case ServerSettings.HostingOption.SelfHosted:
45                 bool hidePort = false;
46                 if (settings.Protocol == ConnectionProtocol.Udp && (settings.ServerPort == 4530 || settings.ServerPort == 0))
47                 {
48                     settings.ServerPort = 5055;
49                 }
50                 else if (settings.Protocol == ConnectionProtocol.Tcp && (settings.ServerPort == 5055 || settings.ServerPort == 0))
51                 {
52                     settings.ServerPort = 4530;
53                 }
54                 #if RHTTP
55                 if (settings.Protocol == ConnectionProtocol.RHttp)
56                 {
57                     settings.ServerPort = 0;
58                     hidePort = true;
59                 }
60                 #endif
61                 settings.ServerAddress = EditorGUILayout.TextField("Server Address", settings.ServerAddress);
62                 settings.ServerAddress = settings.ServerAddress.Trim();
63                 if (!hidePort)
64                 {
65                     settings.ServerPort = EditorGUILayout.IntField("Server Port", settings.ServerPort);
66                 }
67                 settings.Protocol = (ConnectionProtocol)EditorGUILayout.EnumPopup("Protocol", settings.Protocol);
68                 settings.AppID = EditorGUILayout.TextField("AppId", settings.AppID);
69                 break;
70
71             case ServerSettings.HostingOption.OfflineMode:
72                 EditorGUI.indentLevel = 0;
73                 EditorGUILayout.HelpBox("In 'Offline Mode', the client does not communicate with a server.\nAll settings are hidden currently.", MessageType.Info);
74                 break;
75
76             case ServerSettings.HostingOption.NotSet:
77                 EditorGUI.indentLevel = 0;
78                 EditorGUILayout.HelpBox("Hosting is 'Not Set'.\nConnectUsingSettings() will not be able to connect.\nSelect another option or run the PUN Wizard.", MessageType.Info);
79                 break;
80
81             default:
82                 DrawDefaultInspector();
83                 break;
84         }
85
86         if (PhotonEditor.CheckPunPlus())
87         {
88             settings.Protocol = ConnectionProtocol.Udp;
89             EditorGUILayout.HelpBox("You seem to use PUN+.\nPUN+ only supports reliable UDP so the protocol is locked.", MessageType.Info);
90         }
91
92         settings.AppID = settings.AppID.Trim();
93
94         EditorGUI.indentLevel = 0;
95         SerializedObject sObj = new SerializedObject(this.target);
96         SerializedProperty sRpcs = sObj.FindProperty("RpcList");
97         EditorGUILayout.PropertyField(sRpcs, true);
98         sObj.ApplyModifiedProperties();
99
100         GUILayout.BeginHorizontal();
101         GUILayout.Space(20);
102         if (GUILayout.Button("Refresh RPCs"))
103         {
104             PhotonEditor.UpdateRpcList();
105             Repaint();
106         }
107         if (GUILayout.Button("Clear RPCs"))
108         {
109             PhotonEditor.ClearRpcList();
110         }
111         if (GUILayout.Button("Log HashCode"))
112         {
113             Debug.Log("RPC-List HashCode: " + RpcListHashCode() + ". Make sure clients that send each other RPCs have the same RPC-List.");
114         }
115         GUILayout.Space(20);
116         GUILayout.EndHorizontal();
117
118         //SerializedProperty sp = serializedObject.FindProperty("RpcList");
119         //EditorGUILayout.PropertyField(sp, true);
120
121         if (GUI.changed)
122         {
123             EditorUtility.SetDirty(target);
124         }
125     }

45     private static short SerializeVector3(MemoryStream outStream, object customobject)
46     {
47         Vector3 vo = (Vector3)customobject;
48
49         int index = 0;
50         lock (memVector3)
51         {
52             byte[] bytes = memVector3;
53             Protocol.Serialize(vo.x, bytes, ref index);
54             Protocol.Serialize(vo.y, bytes, ref index);
55             Protocol.Serialize(vo.z, bytes, ref index);
56             outStream.Write(bytes, 0, 3 * 4);
57         }
58
59         return 3 * 4;
60     }

62     private static object DeserializeVector3(MemoryStream inStream, short length)
63     {
64         Vector3 vo = new Vector3();
65         lock (memVector3)
66         {
67             inStream.Read(memVector3, 0, 3 * 4);
68             int index = 0;
69             Protocol.Deserialize(out vo.x, memVector3, ref index);
70             Protocol.Deserialize(out vo.y, memVector3, ref index);
71             Protocol.Deserialize(out vo.z, memVector3, ref index);
72         }
73
74         return vo;
75     }

79     private static short SerializeVector2(MemoryStream outStream, object customobject)
80     {
81         Vector2 vo = (Vector2)customobject;
82         lock (memVector2)
83         {
84             byte[] bytes = memVector2;
85             int index = 0;
86             Protocol.Serialize(vo.x, bytes, ref index);
87             Protocol.Serialize(vo.y, bytes, ref index);
88             outStream.Write(bytes, 0, 2 * 4);
89         }
90
91         return 2 * 4;
92     }

94     private static object DeserializeVector2(MemoryStream inStream, short length)
95     {
96         Vector2 vo = new Vector2();
97         lock (memVector2)
98         {
99             inStream.Read(memVector2, 0, 2 * 4);
100             int index = 0;
101             Protocol.Deserialize(out vo.x, memVector2, ref index);
102             Protocol.Deserialize(out vo.y, memVector2, ref index);
103         }
104
105         return vo;
106     }