Dec2017-Script-Dump/UnityEngine.Networking/NetworkTransform.cs

using System;

namespace UnityEngine.Networking
{
	// Token: 0x0200005D RID: 93
	[DisallowMultipleComponent]
	[AddComponentMenu("Network/NetworkTransform")]
	public class NetworkTransform : NetworkBehaviour
	{
		// Token: 0x170000C4 RID: 196
		// (get) Token: 0x06000492 RID: 1170 RVA: 0x0001A1B0 File Offset: 0x000183B0
		// (set) Token: 0x06000493 RID: 1171 RVA: 0x0001A1CB File Offset: 0x000183CB
		public NetworkTransform.TransformSyncMode transformSyncMode
		{
			get
			{
				return this.m_TransformSyncMode;
			}
			set
			{
				this.m_TransformSyncMode = value;
			}
		}

		// Token: 0x170000C5 RID: 197
		// (get) Token: 0x06000494 RID: 1172 RVA: 0x0001A1D8 File Offset: 0x000183D8
		// (set) Token: 0x06000495 RID: 1173 RVA: 0x0001A1F3 File Offset: 0x000183F3
		public float sendInterval
		{
			get
			{
				return this.m_SendInterval;
			}
			set
			{
				this.m_SendInterval = value;
			}
		}

		// Token: 0x170000C6 RID: 198
		// (get) Token: 0x06000496 RID: 1174 RVA: 0x0001A200 File Offset: 0x00018400
		// (set) Token: 0x06000497 RID: 1175 RVA: 0x0001A21B File Offset: 0x0001841B
		public NetworkTransform.AxisSyncMode syncRotationAxis
		{
			get
			{
				return this.m_SyncRotationAxis;
			}
			set
			{
				this.m_SyncRotationAxis = value;
			}
		}

		// Token: 0x170000C7 RID: 199
		// (get) Token: 0x06000498 RID: 1176 RVA: 0x0001A228 File Offset: 0x00018428
		// (set) Token: 0x06000499 RID: 1177 RVA: 0x0001A243 File Offset: 0x00018443
		public NetworkTransform.CompressionSyncMode rotationSyncCompression
		{
			get
			{
				return this.m_RotationSyncCompression;
			}
			set
			{
				this.m_RotationSyncCompression = value;
			}
		}

		// Token: 0x170000C8 RID: 200
		// (get) Token: 0x0600049A RID: 1178 RVA: 0x0001A250 File Offset: 0x00018450
		// (set) Token: 0x0600049B RID: 1179 RVA: 0x0001A26B File Offset: 0x0001846B
		public bool syncSpin
		{
			get
			{
				return this.m_SyncSpin;
			}
			set
			{
				this.m_SyncSpin = value;
			}
		}

		// Token: 0x170000C9 RID: 201
		// (get) Token: 0x0600049C RID: 1180 RVA: 0x0001A278 File Offset: 0x00018478
		// (set) Token: 0x0600049D RID: 1181 RVA: 0x0001A293 File Offset: 0x00018493
		public float movementTheshold
		{
			get
			{
				return this.m_MovementTheshold;
			}
			set
			{
				this.m_MovementTheshold = value;
			}
		}

		// Token: 0x170000CA RID: 202
		// (get) Token: 0x0600049E RID: 1182 RVA: 0x0001A2A0 File Offset: 0x000184A0
		// (set) Token: 0x0600049F RID: 1183 RVA: 0x0001A2BB File Offset: 0x000184BB
		public float velocityThreshold
		{
			get
			{
				return this.m_VelocityThreshold;
			}
			set
			{
				this.m_VelocityThreshold = value;
			}
		}

		// Token: 0x170000CB RID: 203
		// (get) Token: 0x060004A0 RID: 1184 RVA: 0x0001A2C8 File Offset: 0x000184C8
		// (set) Token: 0x060004A1 RID: 1185 RVA: 0x0001A2E3 File Offset: 0x000184E3
		public float snapThreshold
		{
			get
			{
				return this.m_SnapThreshold;
			}
			set
			{
				this.m_SnapThreshold = value;
			}
		}

		// Token: 0x170000CC RID: 204
		// (get) Token: 0x060004A2 RID: 1186 RVA: 0x0001A2F0 File Offset: 0x000184F0
		// (set) Token: 0x060004A3 RID: 1187 RVA: 0x0001A30B File Offset: 0x0001850B
		public float interpolateRotation
		{
			get
			{
				return this.m_InterpolateRotation;
			}
			set
			{
				this.m_InterpolateRotation = value;
			}
		}

		// Token: 0x170000CD RID: 205
		// (get) Token: 0x060004A4 RID: 1188 RVA: 0x0001A318 File Offset: 0x00018518
		// (set) Token: 0x060004A5 RID: 1189 RVA: 0x0001A333 File Offset: 0x00018533
		public float interpolateMovement
		{
			get
			{
				return this.m_InterpolateMovement;
			}
			set
			{
				this.m_InterpolateMovement = value;
			}
		}

		// Token: 0x170000CE RID: 206
		// (get) Token: 0x060004A6 RID: 1190 RVA: 0x0001A340 File Offset: 0x00018540
		// (set) Token: 0x060004A7 RID: 1191 RVA: 0x0001A35B File Offset: 0x0001855B
		public NetworkTransform.ClientMoveCallback3D clientMoveCallback3D
		{
			get
			{
				return this.m_ClientMoveCallback3D;
			}
			set
			{
				this.m_ClientMoveCallback3D = value;
			}
		}

		// Token: 0x170000CF RID: 207
		// (get) Token: 0x060004A8 RID: 1192 RVA: 0x0001A368 File Offset: 0x00018568
		// (set) Token: 0x060004A9 RID: 1193 RVA: 0x0001A383 File Offset: 0x00018583
		public NetworkTransform.ClientMoveCallback2D clientMoveCallback2D
		{
			get
			{
				return this.m_ClientMoveCallback2D;
			}
			set
			{
				this.m_ClientMoveCallback2D = value;
			}
		}

		// Token: 0x170000D0 RID: 208
		// (get) Token: 0x060004AA RID: 1194 RVA: 0x0001A390 File Offset: 0x00018590
		public CharacterController characterContoller
		{
			get
			{
				return this.m_CharacterController;
			}
		}

		// Token: 0x170000D1 RID: 209
		// (get) Token: 0x060004AB RID: 1195 RVA: 0x0001A3AC File Offset: 0x000185AC
		public Rigidbody rigidbody3D
		{
			get
			{
				return this.m_RigidBody3D;
			}
		}

		// Token: 0x170000D2 RID: 210
		// (get) Token: 0x060004AC RID: 1196 RVA: 0x0001A3C8 File Offset: 0x000185C8
		public Rigidbody2D rigidbody2D
		{
			get
			{
				return this.m_RigidBody2D;
			}
		}

		// Token: 0x170000D3 RID: 211
		// (get) Token: 0x060004AD RID: 1197 RVA: 0x0001A3E4 File Offset: 0x000185E4
		public float lastSyncTime
		{
			get
			{
				return this.m_LastClientSyncTime;
			}
		}

		// Token: 0x170000D4 RID: 212
		// (get) Token: 0x060004AE RID: 1198 RVA: 0x0001A400 File Offset: 0x00018600
		public Vector3 targetSyncPosition
		{
			get
			{
				return this.m_TargetSyncPosition;
			}
		}

		// Token: 0x170000D5 RID: 213
		// (get) Token: 0x060004AF RID: 1199 RVA: 0x0001A41C File Offset: 0x0001861C
		public Vector3 targetSyncVelocity
		{
			get
			{
				return this.m_TargetSyncVelocity;
			}
		}

		// Token: 0x170000D6 RID: 214
		// (get) Token: 0x060004B0 RID: 1200 RVA: 0x0001A438 File Offset: 0x00018638
		public Quaternion targetSyncRotation3D
		{
			get
			{
				return this.m_TargetSyncRotation3D;
			}
		}

		// Token: 0x170000D7 RID: 215
		// (get) Token: 0x060004B1 RID: 1201 RVA: 0x0001A454 File Offset: 0x00018654
		public float targetSyncRotation2D
		{
			get
			{
				return this.m_TargetSyncRotation2D;
			}
		}

		// Token: 0x170000D8 RID: 216
		// (get) Token: 0x060004B2 RID: 1202 RVA: 0x0001A470 File Offset: 0x00018670
		// (set) Token: 0x060004B3 RID: 1203 RVA: 0x0001A48B File Offset: 0x0001868B
		public bool grounded
		{
			get
			{
				return this.m_Grounded;
			}
			set
			{
				this.m_Grounded = value;
			}
		}

		// Token: 0x060004B4 RID: 1204 RVA: 0x0001A498 File Offset: 0x00018698
		private void OnValidate()
		{
			if (this.m_TransformSyncMode < NetworkTransform.TransformSyncMode.SyncNone || this.m_TransformSyncMode > NetworkTransform.TransformSyncMode.SyncCharacterController)
			{
				this.m_TransformSyncMode = NetworkTransform.TransformSyncMode.SyncTransform;
			}
			if (this.m_SendInterval < 0f)
			{
				this.m_SendInterval = 0f;
			}
			if (this.m_SyncRotationAxis < NetworkTransform.AxisSyncMode.None || this.m_SyncRotationAxis > NetworkTransform.AxisSyncMode.AxisXYZ)
			{
				this.m_SyncRotationAxis = NetworkTransform.AxisSyncMode.None;
			}
			if (this.m_MovementTheshold < 0f)
			{
				this.m_MovementTheshold = 0f;
			}
			if (this.m_VelocityThreshold < 0f)
			{
				this.m_VelocityThreshold = 0f;
			}
			if (this.m_SnapThreshold < 0f)
			{
				this.m_SnapThreshold = 0.01f;
			}
			if (this.m_InterpolateRotation < 0f)
			{
				this.m_InterpolateRotation = 0.01f;
			}
			if (this.m_InterpolateMovement < 0f)
			{
				this.m_InterpolateMovement = 0.01f;
			}
		}

		// Token: 0x060004B5 RID: 1205 RVA: 0x0001A598 File Offset: 0x00018798
		private void Awake()
		{
			this.m_RigidBody3D = base.GetComponent<Rigidbody>();
			this.m_RigidBody2D = base.GetComponent<Rigidbody2D>();
			this.m_CharacterController = base.GetComponent<CharacterController>();
			this.m_PrevPosition = base.transform.position;
			this.m_PrevRotation = base.transform.rotation;
			this.m_PrevVelocity = 0f;
			if (base.localPlayerAuthority)
			{
				this.m_LocalTransformWriter = new NetworkWriter();
			}
		}

		// Token: 0x060004B6 RID: 1206 RVA: 0x0001A60F File Offset: 0x0001880F
		public override void OnStartServer()
		{
			this.m_LastClientSyncTime = 0f;
		}

		// Token: 0x060004B7 RID: 1207 RVA: 0x0001A620 File Offset: 0x00018820
		public override bool OnSerialize(NetworkWriter writer, bool initialState)
		{
			if (!initialState)
			{
				if (base.syncVarDirtyBits == 0U)
				{
					writer.WritePackedUInt32(0U);
					return false;
				}
				writer.WritePackedUInt32(1U);
			}
			switch (this.transformSyncMode)
			{
			case NetworkTransform.TransformSyncMode.SyncNone:
				return false;
			case NetworkTransform.TransformSyncMode.SyncTransform:
				this.SerializeModeTransform(writer);
				break;
			case NetworkTransform.TransformSyncMode.SyncRigidbody2D:
				this.SerializeMode2D(writer);
				break;
			case NetworkTransform.TransformSyncMode.SyncRigidbody3D:
				this.SerializeMode3D(writer);
				break;
			case NetworkTransform.TransformSyncMode.SyncCharacterController:
				this.SerializeModeCharacterController(writer);
				break;
			}
			return true;
		}

		// Token: 0x060004B8 RID: 1208 RVA: 0x0001A6C8 File Offset: 0x000188C8
		private void SerializeModeTransform(NetworkWriter writer)
		{
			writer.Write(base.transform.position);
			if (this.m_SyncRotationAxis != NetworkTransform.AxisSyncMode.None)
			{
				NetworkTransform.SerializeRotation3D(writer, base.transform.rotation, this.syncRotationAxis, this.rotationSyncCompression);
			}
			this.m_PrevPosition = base.transform.position;
			this.m_PrevRotation = base.transform.rotation;
			this.m_PrevVelocity = 0f;
		}

		// Token: 0x060004B9 RID: 1209 RVA: 0x0001A740 File Offset: 0x00018940
		private void VerifySerializeComponentExists()
		{
			bool flag = false;
			Type type = null;
			NetworkTransform.TransformSyncMode transformSyncMode = this.transformSyncMode;
			if (transformSyncMode != NetworkTransform.TransformSyncMode.SyncCharacterController)
			{
				if (transformSyncMode != NetworkTransform.TransformSyncMode.SyncRigidbody2D)
				{
					if (transformSyncMode == NetworkTransform.TransformSyncMode.SyncRigidbody3D)
					{
						if (!this.m_RigidBody3D)
						{
							flag = true;
							type = typeof(Rigidbody);
						}
					}
				}
				else if (!this.m_RigidBody2D)
				{
					flag = true;
					type = typeof(Rigidbody2D);
				}
			}
			else if (!this.m_CharacterController)
			{
				flag = true;
				type = typeof(CharacterController);
			}
			if (flag && type != null)
			{
				throw new InvalidOperationException(string.Format("transformSyncMode set to {0} but no {1} component was found, did you call NetworkServer.Spawn on a prefab?", this.transformSyncMode, type.Name));
			}
		}

		// Token: 0x060004BA RID: 1210 RVA: 0x0001A810 File Offset: 0x00018A10
		private void SerializeMode3D(NetworkWriter writer)
		{
			this.VerifySerializeComponentExists();
			if (base.isServer && this.m_LastClientSyncTime != 0f)
			{
				writer.Write(this.m_TargetSyncPosition);
				NetworkTransform.SerializeVelocity3D(writer, this.m_TargetSyncVelocity, NetworkTransform.CompressionSyncMode.None);
				if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
				{
					NetworkTransform.SerializeRotation3D(writer, this.m_TargetSyncRotation3D, this.syncRotationAxis, this.rotationSyncCompression);
				}
			}
			else
			{
				writer.Write(this.m_RigidBody3D.position);
				NetworkTransform.SerializeVelocity3D(writer, this.m_RigidBody3D.velocity, NetworkTransform.CompressionSyncMode.None);
				if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
				{
					NetworkTransform.SerializeRotation3D(writer, this.m_RigidBody3D.rotation, this.syncRotationAxis, this.rotationSyncCompression);
				}
			}
			if (this.m_SyncSpin)
			{
				NetworkTransform.SerializeSpin3D(writer, this.m_RigidBody3D.angularVelocity, this.syncRotationAxis, this.rotationSyncCompression);
			}
			this.m_PrevPosition = this.m_RigidBody3D.position;
			this.m_PrevRotation = base.transform.rotation;
			this.m_PrevVelocity = this.m_RigidBody3D.velocity.sqrMagnitude;
		}

		// Token: 0x060004BB RID: 1211 RVA: 0x0001A938 File Offset: 0x00018B38
		private void SerializeModeCharacterController(NetworkWriter writer)
		{
			this.VerifySerializeComponentExists();
			if (base.isServer && this.m_LastClientSyncTime != 0f)
			{
				writer.Write(this.m_TargetSyncPosition);
				if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
				{
					NetworkTransform.SerializeRotation3D(writer, this.m_TargetSyncRotation3D, this.syncRotationAxis, this.rotationSyncCompression);
				}
			}
			else
			{
				writer.Write(base.transform.position);
				if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
				{
					NetworkTransform.SerializeRotation3D(writer, base.transform.rotation, this.syncRotationAxis, this.rotationSyncCompression);
				}
			}
			this.m_PrevPosition = base.transform.position;
			this.m_PrevRotation = base.transform.rotation;
			this.m_PrevVelocity = 0f;
		}

		// Token: 0x060004BC RID: 1212 RVA: 0x0001AA0C File Offset: 0x00018C0C
		private void SerializeMode2D(NetworkWriter writer)
		{
			this.VerifySerializeComponentExists();
			if (base.isServer && this.m_LastClientSyncTime != 0f)
			{
				writer.Write(this.m_TargetSyncPosition);
				NetworkTransform.SerializeVelocity2D(writer, this.m_TargetSyncVelocity, NetworkTransform.CompressionSyncMode.None);
				if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
				{
					float num = this.m_TargetSyncRotation2D % 360f;
					if (num < 0f)
					{
						num += 360f;
					}
					NetworkTransform.SerializeRotation2D(writer, num, this.rotationSyncCompression);
				}
			}
			else
			{
				writer.Write(this.m_RigidBody2D.position);
				NetworkTransform.SerializeVelocity2D(writer, this.m_RigidBody2D.velocity, NetworkTransform.CompressionSyncMode.None);
				if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
				{
					float num2 = this.m_RigidBody2D.rotation % 360f;
					if (num2 < 0f)
					{
						num2 += 360f;
					}
					NetworkTransform.SerializeRotation2D(writer, num2, this.rotationSyncCompression);
				}
			}
			if (this.m_SyncSpin)
			{
				NetworkTransform.SerializeSpin2D(writer, this.m_RigidBody2D.angularVelocity, this.rotationSyncCompression);
			}
			this.m_PrevPosition = this.m_RigidBody2D.position;
			this.m_PrevRotation = base.transform.rotation;
			this.m_PrevVelocity = this.m_RigidBody2D.velocity.sqrMagnitude;
		}

		// Token: 0x060004BD RID: 1213 RVA: 0x0001AB68 File Offset: 0x00018D68
		public override void OnDeserialize(NetworkReader reader, bool initialState)
		{
			if (!base.isServer || !NetworkServer.localClientActive)
			{
				if (!initialState)
				{
					if (reader.ReadPackedUInt32() == 0U)
					{
						return;
					}
				}
				switch (this.transformSyncMode)
				{
				case NetworkTransform.TransformSyncMode.SyncNone:
					return;
				case NetworkTransform.TransformSyncMode.SyncTransform:
					this.UnserializeModeTransform(reader, initialState);
					break;
				case NetworkTransform.TransformSyncMode.SyncRigidbody2D:
					this.UnserializeMode2D(reader, initialState);
					break;
				case NetworkTransform.TransformSyncMode.SyncRigidbody3D:
					this.UnserializeMode3D(reader, initialState);
					break;
				case NetworkTransform.TransformSyncMode.SyncCharacterController:
					this.UnserializeModeCharacterController(reader, initialState);
					break;
				}
				this.m_LastClientSyncTime = Time.time;
			}
		}

		// Token: 0x060004BE RID: 1214 RVA: 0x0001AC18 File Offset: 0x00018E18
		private void UnserializeModeTransform(NetworkReader reader, bool initialState)
		{
			if (base.hasAuthority)
			{
				reader.ReadVector3();
				if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
				{
					NetworkTransform.UnserializeRotation3D(reader, this.syncRotationAxis, this.rotationSyncCompression);
				}
			}
			else if (base.isServer && this.m_ClientMoveCallback3D != null)
			{
				Vector3 vector = reader.ReadVector3();
				Vector3 zero = Vector3.zero;
				Quaternion quaternion = Quaternion.identity;
				if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
				{
					quaternion = NetworkTransform.UnserializeRotation3D(reader, this.syncRotationAxis, this.rotationSyncCompression);
				}
				if (this.m_ClientMoveCallback3D(ref vector, ref zero, ref quaternion))
				{
					base.transform.position = vector;
					if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
					{
						base.transform.rotation = quaternion;
					}
				}
			}
			else
			{
				base.transform.position = reader.ReadVector3();
				if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
				{
					base.transform.rotation = NetworkTransform.UnserializeRotation3D(reader, this.syncRotationAxis, this.rotationSyncCompression);
				}
			}
		}

		// Token: 0x060004BF RID: 1215 RVA: 0x0001AD34 File Offset: 0x00018F34
		private void UnserializeMode3D(NetworkReader reader, bool initialState)
		{
			if (base.hasAuthority)
			{
				reader.ReadVector3();
				reader.ReadVector3();
				if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
				{
					NetworkTransform.UnserializeRotation3D(reader, this.syncRotationAxis, this.rotationSyncCompression);
				}
				if (this.syncSpin)
				{
					NetworkTransform.UnserializeSpin3D(reader, this.syncRotationAxis, this.rotationSyncCompression);
				}
			}
			else
			{
				if (base.isServer && this.m_ClientMoveCallback3D != null)
				{
					Vector3 vector = reader.ReadVector3();
					Vector3 vector2 = reader.ReadVector3();
					Quaternion quaternion = Quaternion.identity;
					if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
					{
						quaternion = NetworkTransform.UnserializeRotation3D(reader, this.syncRotationAxis, this.rotationSyncCompression);
					}
					if (!this.m_ClientMoveCallback3D(ref vector, ref vector2, ref quaternion))
					{
						return;
					}
					this.m_TargetSyncPosition = vector;
					this.m_TargetSyncVelocity = vector2;
					if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
					{
						this.m_TargetSyncRotation3D = quaternion;
					}
				}
				else
				{
					this.m_TargetSyncPosition = reader.ReadVector3();
					this.m_TargetSyncVelocity = reader.ReadVector3();
					if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
					{
						this.m_TargetSyncRotation3D = NetworkTransform.UnserializeRotation3D(reader, this.syncRotationAxis, this.rotationSyncCompression);
					}
				}
				if (this.syncSpin)
				{
					this.m_TargetSyncAngularVelocity3D = NetworkTransform.UnserializeSpin3D(reader, this.syncRotationAxis, this.rotationSyncCompression);
				}
				if (!(this.m_RigidBody3D == null))
				{
					if (base.isServer && !base.isClient)
					{
						this.m_RigidBody3D.MovePosition(this.m_TargetSyncPosition);
						this.m_RigidBody3D.MoveRotation(this.m_TargetSyncRotation3D);
						this.m_RigidBody3D.velocity = this.m_TargetSyncVelocity;
					}
					else if (this.GetNetworkSendInterval() == 0f)
					{
						this.m_RigidBody3D.MovePosition(this.m_TargetSyncPosition);
						this.m_RigidBody3D.velocity = this.m_TargetSyncVelocity;
						if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
						{
							this.m_RigidBody3D.MoveRotation(this.m_TargetSyncRotation3D);
						}
						if (this.syncSpin)
						{
							this.m_RigidBody3D.angularVelocity = this.m_TargetSyncAngularVelocity3D;
						}
					}
					else
					{
						float magnitude = (this.m_RigidBody3D.position - this.m_TargetSyncPosition).magnitude;
						if (magnitude > this.snapThreshold)
						{
							this.m_RigidBody3D.position = this.m_TargetSyncPosition;
							this.m_RigidBody3D.velocity = this.m_TargetSyncVelocity;
						}
						if (this.interpolateRotation == 0f && this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
						{
							this.m_RigidBody3D.rotation = this.m_TargetSyncRotation3D;
							if (this.syncSpin)
							{
								this.m_RigidBody3D.angularVelocity = this.m_TargetSyncAngularVelocity3D;
							}
						}
						if (this.m_InterpolateMovement == 0f)
						{
							this.m_RigidBody3D.position = this.m_TargetSyncPosition;
						}
						if (initialState && this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
						{
							this.m_RigidBody3D.rotation = this.m_TargetSyncRotation3D;
						}
					}
				}
			}
		}

		// Token: 0x060004C0 RID: 1216 RVA: 0x0001B058 File Offset: 0x00019258
		private void UnserializeMode2D(NetworkReader reader, bool initialState)
		{
			if (base.hasAuthority)
			{
				reader.ReadVector2();
				reader.ReadVector2();
				if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
				{
					NetworkTransform.UnserializeRotation2D(reader, this.rotationSyncCompression);
				}
				if (this.syncSpin)
				{
					NetworkTransform.UnserializeSpin2D(reader, this.rotationSyncCompression);
				}
			}
			else if (!(this.m_RigidBody2D == null))
			{
				if (base.isServer && this.m_ClientMoveCallback2D != null)
				{
					Vector2 vector = reader.ReadVector2();
					Vector2 vector2 = reader.ReadVector2();
					float num = 0f;
					if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
					{
						num = NetworkTransform.UnserializeRotation2D(reader, this.rotationSyncCompression);
					}
					if (!this.m_ClientMoveCallback2D(ref vector, ref vector2, ref num))
					{
						return;
					}
					this.m_TargetSyncPosition = vector;
					this.m_TargetSyncVelocity = vector2;
					if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
					{
						this.m_TargetSyncRotation2D = num;
					}
				}
				else
				{
					this.m_TargetSyncPosition = reader.ReadVector2();
					this.m_TargetSyncVelocity = reader.ReadVector2();
					if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
					{
						this.m_TargetSyncRotation2D = NetworkTransform.UnserializeRotation2D(reader, this.rotationSyncCompression);
					}
				}
				if (this.syncSpin)
				{
					this.m_TargetSyncAngularVelocity2D = NetworkTransform.UnserializeSpin2D(reader, this.rotationSyncCompression);
				}
				if (base.isServer && !base.isClient)
				{
					base.transform.position = this.m_TargetSyncPosition;
					this.m_RigidBody2D.MoveRotation(this.m_TargetSyncRotation2D);
					this.m_RigidBody2D.velocity = this.m_TargetSyncVelocity;
				}
				else if (this.GetNetworkSendInterval() == 0f)
				{
					base.transform.position = this.m_TargetSyncPosition;
					this.m_RigidBody2D.velocity = this.m_TargetSyncVelocity;
					if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
					{
						this.m_RigidBody2D.MoveRotation(this.m_TargetSyncRotation2D);
					}
					if (this.syncSpin)
					{
						this.m_RigidBody2D.angularVelocity = this.m_TargetSyncAngularVelocity2D;
					}
				}
				else
				{
					float magnitude = (this.m_RigidBody2D.position - this.m_TargetSyncPosition).magnitude;
					if (magnitude > this.snapThreshold)
					{
						this.m_RigidBody2D.position = this.m_TargetSyncPosition;
						this.m_RigidBody2D.velocity = this.m_TargetSyncVelocity;
					}
					if (this.interpolateRotation == 0f && this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
					{
						this.m_RigidBody2D.rotation = this.m_TargetSyncRotation2D;
						if (this.syncSpin)
						{
							this.m_RigidBody2D.angularVelocity = this.m_TargetSyncAngularVelocity2D;
						}
					}
					if (this.m_InterpolateMovement == 0f)
					{
						this.m_RigidBody2D.position = this.m_TargetSyncPosition;
					}
					if (initialState)
					{
						this.m_RigidBody2D.rotation = this.m_TargetSyncRotation2D;
					}
				}
			}
		}

		// Token: 0x060004C1 RID: 1217 RVA: 0x0001B384 File Offset: 0x00019584
		private void UnserializeModeCharacterController(NetworkReader reader, bool initialState)
		{
			if (base.hasAuthority)
			{
				reader.ReadVector3();
				if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
				{
					NetworkTransform.UnserializeRotation3D(reader, this.syncRotationAxis, this.rotationSyncCompression);
				}
			}
			else
			{
				if (base.isServer && this.m_ClientMoveCallback3D != null)
				{
					Vector3 vector = reader.ReadVector3();
					Quaternion quaternion = Quaternion.identity;
					if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
					{
						quaternion = NetworkTransform.UnserializeRotation3D(reader, this.syncRotationAxis, this.rotationSyncCompression);
					}
					if (this.m_CharacterController == null)
					{
						return;
					}
					Vector3 velocity = this.m_CharacterController.velocity;
					if (!this.m_ClientMoveCallback3D(ref vector, ref velocity, ref quaternion))
					{
						return;
					}
					this.m_TargetSyncPosition = vector;
					this.m_TargetSyncVelocity = velocity;
					if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
					{
						this.m_TargetSyncRotation3D = quaternion;
					}
				}
				else
				{
					this.m_TargetSyncPosition = reader.ReadVector3();
					if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
					{
						this.m_TargetSyncRotation3D = NetworkTransform.UnserializeRotation3D(reader, this.syncRotationAxis, this.rotationSyncCompression);
					}
				}
				if (!(this.m_CharacterController == null))
				{
					Vector3 vector2 = this.m_TargetSyncPosition - base.transform.position;
					Vector3 vector3 = vector2 / this.GetNetworkSendInterval();
					this.m_FixedPosDiff = vector3 * Time.fixedDeltaTime;
					if (base.isServer && !base.isClient)
					{
						base.transform.position = this.m_TargetSyncPosition;
						base.transform.rotation = this.m_TargetSyncRotation3D;
					}
					else if (this.GetNetworkSendInterval() == 0f)
					{
						base.transform.position = this.m_TargetSyncPosition;
						if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
						{
							base.transform.rotation = this.m_TargetSyncRotation3D;
						}
					}
					else
					{
						float magnitude = (base.transform.position - this.m_TargetSyncPosition).magnitude;
						if (magnitude > this.snapThreshold)
						{
							base.transform.position = this.m_TargetSyncPosition;
						}
						if (this.interpolateRotation == 0f && this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
						{
							base.transform.rotation = this.m_TargetSyncRotation3D;
						}
						if (this.m_InterpolateMovement == 0f)
						{
							base.transform.position = this.m_TargetSyncPosition;
						}
						if (initialState && this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
						{
							base.transform.rotation = this.m_TargetSyncRotation3D;
						}
					}
				}
			}
		}

		// Token: 0x060004C2 RID: 1218 RVA: 0x0001B634 File Offset: 0x00019834
		private void FixedUpdate()
		{
			if (base.isServer)
			{
				this.FixedUpdateServer();
			}
			if (base.isClient)
			{
				this.FixedUpdateClient();
			}
		}

		// Token: 0x060004C3 RID: 1219 RVA: 0x0001B660 File Offset: 0x00019860
		private void FixedUpdateServer()
		{
			if (base.syncVarDirtyBits == 0U)
			{
				if (NetworkServer.active)
				{
					if (base.isServer)
					{
						if (this.GetNetworkSendInterval() != 0f)
						{
							float num = (base.transform.position - this.m_PrevPosition).magnitude;
							if (num < this.movementTheshold)
							{
								num = Quaternion.Angle(this.m_PrevRotation, base.transform.rotation);
								if (num < this.movementTheshold)
								{
									if (!this.CheckVelocityChanged())
									{
										return;
									}
								}
							}
							base.SetDirtyBit(1U);
						}
					}
				}
			}
		}

		// Token: 0x060004C4 RID: 1220 RVA: 0x0001B71C File Offset: 0x0001991C
		private bool CheckVelocityChanged()
		{
			NetworkTransform.TransformSyncMode transformSyncMode = this.transformSyncMode;
			bool flag;
			if (transformSyncMode != NetworkTransform.TransformSyncMode.SyncRigidbody2D)
			{
				flag = transformSyncMode == NetworkTransform.TransformSyncMode.SyncRigidbody3D && (this.m_RigidBody3D && this.m_VelocityThreshold > 0f) && Mathf.Abs(this.m_RigidBody3D.velocity.sqrMagnitude - this.m_PrevVelocity) >= this.m_VelocityThreshold;
			}
			else
			{
				flag = this.m_RigidBody2D && this.m_VelocityThreshold > 0f && Mathf.Abs(this.m_RigidBody2D.velocity.sqrMagnitude - this.m_PrevVelocity) >= this.m_VelocityThreshold;
			}
			return flag;
		}

		// Token: 0x060004C5 RID: 1221 RVA: 0x0001B800 File Offset: 0x00019A00
		private void FixedUpdateClient()
		{
			if (this.m_LastClientSyncTime != 0f)
			{
				if (NetworkServer.active || NetworkClient.active)
				{
					if (base.isServer || base.isClient)
					{
						if (this.GetNetworkSendInterval() != 0f)
						{
							if (!base.hasAuthority)
							{
								switch (this.transformSyncMode)
								{
								case NetworkTransform.TransformSyncMode.SyncRigidbody2D:
									this.InterpolateTransformMode2D();
									break;
								case NetworkTransform.TransformSyncMode.SyncRigidbody3D:
									this.InterpolateTransformMode3D();
									break;
								case NetworkTransform.TransformSyncMode.SyncCharacterController:
									this.InterpolateTransformModeCharacterController();
									break;
								}
							}
						}
					}
				}
			}
		}

		// Token: 0x060004C6 RID: 1222 RVA: 0x0001B8D4 File Offset: 0x00019AD4
		private void InterpolateTransformMode3D()
		{
			if (this.m_InterpolateMovement != 0f)
			{
				Vector3 vector = (this.m_TargetSyncPosition - this.m_RigidBody3D.position) * this.m_InterpolateMovement / this.GetNetworkSendInterval();
				this.m_RigidBody3D.velocity = vector;
			}
			if (this.interpolateRotation != 0f)
			{
				this.m_RigidBody3D.MoveRotation(Quaternion.Slerp(this.m_RigidBody3D.rotation, this.m_TargetSyncRotation3D, Time.fixedDeltaTime * this.interpolateRotation));
			}
			this.m_TargetSyncPosition += this.m_TargetSyncVelocity * Time.fixedDeltaTime * 0.1f;
		}

		// Token: 0x060004C7 RID: 1223 RVA: 0x0001B998 File Offset: 0x00019B98
		private void InterpolateTransformModeCharacterController()
		{
			if (!(this.m_FixedPosDiff == Vector3.zero) || !(this.m_TargetSyncRotation3D == base.transform.rotation))
			{
				if (this.m_InterpolateMovement != 0f)
				{
					this.m_CharacterController.Move(this.m_FixedPosDiff * this.m_InterpolateMovement);
				}
				if (this.interpolateRotation != 0f)
				{
					base.transform.rotation = Quaternion.Slerp(base.transform.rotation, this.m_TargetSyncRotation3D, Time.fixedDeltaTime * this.interpolateRotation * 10f);
				}
				if (Time.time - this.m_LastClientSyncTime > this.GetNetworkSendInterval())
				{
					this.m_FixedPosDiff = Vector3.zero;
					Vector3 vector = this.m_TargetSyncPosition - base.transform.position;
					this.m_CharacterController.Move(vector);
				}
			}
		}

		// Token: 0x060004C8 RID: 1224 RVA: 0x0001BA98 File Offset: 0x00019C98
		private void InterpolateTransformMode2D()
		{
			if (this.m_InterpolateMovement != 0f)
			{
				Vector2 velocity = this.m_RigidBody2D.velocity;
				Vector2 vector = (this.m_TargetSyncPosition - this.m_RigidBody2D.position) * this.m_InterpolateMovement / this.GetNetworkSendInterval();
				if (!this.m_Grounded && vector.y < 0f)
				{
					vector.y = velocity.y;
				}
				this.m_RigidBody2D.velocity = vector;
			}
			if (this.interpolateRotation != 0f)
			{
				float num = this.m_RigidBody2D.rotation % 360f;
				if (num < 0f)
				{
					num += 360f;
				}
				Quaternion quaternion = Quaternion.Slerp(base.transform.rotation, Quaternion.Euler(0f, 0f, this.m_TargetSyncRotation2D), Time.fixedDeltaTime * this.interpolateRotation / this.GetNetworkSendInterval());
				this.m_RigidBody2D.MoveRotation(quaternion.eulerAngles.z);
				this.m_TargetSyncRotation2D += this.m_TargetSyncAngularVelocity2D * Time.fixedDeltaTime * 0.1f;
			}
			this.m_TargetSyncPosition += this.m_TargetSyncVelocity * Time.fixedDeltaTime * 0.1f;
		}

		// Token: 0x060004C9 RID: 1225 RVA: 0x0001BC08 File Offset: 0x00019E08
		private void Update()
		{
			if (base.hasAuthority)
			{
				if (base.localPlayerAuthority)
				{
					if (!NetworkServer.active)
					{
						if (Time.time - this.m_LastClientSendTime > this.GetNetworkSendInterval())
						{
							this.SendTransform();
							this.m_LastClientSendTime = Time.time;
						}
					}
				}
			}
		}

		// Token: 0x060004CA RID: 1226 RVA: 0x0001BC70 File Offset: 0x00019E70
		private bool HasMoved()
		{
			float num;
			if (this.m_RigidBody3D != null)
			{
				num = (this.m_RigidBody3D.position - this.m_PrevPosition).magnitude;
			}
			else if (this.m_RigidBody2D != null)
			{
				num = (this.m_RigidBody2D.position - this.m_PrevPosition).magnitude;
			}
			else
			{
				num = (base.transform.position - this.m_PrevPosition).magnitude;
			}
			bool flag;
			if (num > 1E-05f)
			{
				flag = true;
			}
			else
			{
				if (this.m_RigidBody3D != null)
				{
					num = Quaternion.Angle(this.m_RigidBody3D.rotation, this.m_PrevRotation);
				}
				else if (this.m_RigidBody2D != null)
				{
					num = Math.Abs(this.m_RigidBody2D.rotation - this.m_PrevRotation2D);
				}
				else
				{
					num = Quaternion.Angle(base.transform.rotation, this.m_PrevRotation);
				}
				if (num > 1E-05f)
				{
					flag = true;
				}
				else
				{
					if (this.m_RigidBody3D != null)
					{
						num = Mathf.Abs(this.m_RigidBody3D.velocity.sqrMagnitude - this.m_PrevVelocity);
					}
					else if (this.m_RigidBody2D != null)
					{
						num = Mathf.Abs(this.m_RigidBody2D.velocity.sqrMagnitude - this.m_PrevVelocity);
					}
					flag = num > 1E-05f;
				}
			}
			return flag;
		}

		// Token: 0x060004CB RID: 1227 RVA: 0x0001BE44 File Offset: 0x0001A044
		[Client]
		private void SendTransform()
		{
			if (this.HasMoved() && ClientScene.readyConnection != null)
			{
				this.m_LocalTransformWriter.StartMessage(6);
				this.m_LocalTransformWriter.Write(base.netId);
				switch (this.transformSyncMode)
				{
				case NetworkTransform.TransformSyncMode.SyncNone:
					return;
				case NetworkTransform.TransformSyncMode.SyncTransform:
					this.SerializeModeTransform(this.m_LocalTransformWriter);
					break;
				case NetworkTransform.TransformSyncMode.SyncRigidbody2D:
					this.SerializeMode2D(this.m_LocalTransformWriter);
					break;
				case NetworkTransform.TransformSyncMode.SyncRigidbody3D:
					this.SerializeMode3D(this.m_LocalTransformWriter);
					break;
				case NetworkTransform.TransformSyncMode.SyncCharacterController:
					this.SerializeModeCharacterController(this.m_LocalTransformWriter);
					break;
				}
				if (this.m_RigidBody3D != null)
				{
					this.m_PrevPosition = this.m_RigidBody3D.position;
					this.m_PrevRotation = this.m_RigidBody3D.rotation;
					this.m_PrevVelocity = this.m_RigidBody3D.velocity.sqrMagnitude;
				}
				else if (this.m_RigidBody2D != null)
				{
					this.m_PrevPosition = this.m_RigidBody2D.position;
					this.m_PrevRotation2D = this.m_RigidBody2D.rotation;
					this.m_PrevVelocity = this.m_RigidBody2D.velocity.sqrMagnitude;
				}
				else
				{
					this.m_PrevPosition = base.transform.position;
					this.m_PrevRotation = base.transform.rotation;
				}
				this.m_LocalTransformWriter.FinishMessage();
				ClientScene.readyConnection.SendWriter(this.m_LocalTransformWriter, this.GetNetworkChannel());
			}
		}

		// Token: 0x060004CC RID: 1228 RVA: 0x0001BFF0 File Offset: 0x0001A1F0
		public static void HandleTransform(NetworkMessage netMsg)
		{
			NetworkInstanceId networkInstanceId = netMsg.reader.ReadNetworkId();
			GameObject gameObject = NetworkServer.FindLocalObject(networkInstanceId);
			if (gameObject == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("Received NetworkTransform data for GameObject that doesn't exist");
				}
			}
			else
			{
				NetworkTransform component = gameObject.GetComponent<NetworkTransform>();
				if (component == null)
				{
					if (LogFilter.logError)
					{
						Debug.LogError("HandleTransform null target");
					}
				}
				else if (!component.localPlayerAuthority)
				{
					if (LogFilter.logError)
					{
						Debug.LogError("HandleTransform no localPlayerAuthority");
					}
				}
				else if (netMsg.conn.clientOwnedObjects == null)
				{
					if (LogFilter.logError)
					{
						Debug.LogError("HandleTransform object not owned by connection");
					}
				}
				else if (netMsg.conn.clientOwnedObjects.Contains(networkInstanceId))
				{
					switch (component.transformSyncMode)
					{
					case NetworkTransform.TransformSyncMode.SyncNone:
						return;
					case NetworkTransform.TransformSyncMode.SyncTransform:
						component.UnserializeModeTransform(netMsg.reader, false);
						break;
					case NetworkTransform.TransformSyncMode.SyncRigidbody2D:
						component.UnserializeMode2D(netMsg.reader, false);
						break;
					case NetworkTransform.TransformSyncMode.SyncRigidbody3D:
						component.UnserializeMode3D(netMsg.reader, false);
						break;
					case NetworkTransform.TransformSyncMode.SyncCharacterController:
						component.UnserializeModeCharacterController(netMsg.reader, false);
						break;
					}
					component.m_LastClientSyncTime = Time.time;
				}
				else if (LogFilter.logWarn)
				{
					Debug.LogWarning("HandleTransform netId:" + networkInstanceId + " is not for a valid player");
				}
			}
		}

		// Token: 0x060004CD RID: 1229 RVA: 0x0001C180 File Offset: 0x0001A380
		private static void WriteAngle(NetworkWriter writer, float angle, NetworkTransform.CompressionSyncMode compression)
		{
			if (compression != NetworkTransform.CompressionSyncMode.None)
			{
				if (compression != NetworkTransform.CompressionSyncMode.Low)
				{
					if (compression == NetworkTransform.CompressionSyncMode.High)
					{
						writer.Write((short)angle);
					}
				}
				else
				{
					writer.Write((short)angle);
				}
			}
			else
			{
				writer.Write(angle);
			}
		}

		// Token: 0x060004CE RID: 1230 RVA: 0x0001C1D0 File Offset: 0x0001A3D0
		private static float ReadAngle(NetworkReader reader, NetworkTransform.CompressionSyncMode compression)
		{
			float num;
			if (compression != NetworkTransform.CompressionSyncMode.None)
			{
				if (compression != NetworkTransform.CompressionSyncMode.Low)
				{
					if (compression != NetworkTransform.CompressionSyncMode.High)
					{
						num = 0f;
					}
					else
					{
						num = (float)reader.ReadInt16();
					}
				}
				else
				{
					num = (float)reader.ReadInt16();
				}
			}
			else
			{
				num = reader.ReadSingle();
			}
			return num;
		}

		// Token: 0x060004CF RID: 1231 RVA: 0x0001C22C File Offset: 0x0001A42C
		public static void SerializeVelocity3D(NetworkWriter writer, Vector3 velocity, NetworkTransform.CompressionSyncMode compression)
		{
			writer.Write(velocity);
		}

		// Token: 0x060004D0 RID: 1232 RVA: 0x0001C236 File Offset: 0x0001A436
		public static void SerializeVelocity2D(NetworkWriter writer, Vector2 velocity, NetworkTransform.CompressionSyncMode compression)
		{
			writer.Write(velocity);
		}

		// Token: 0x060004D1 RID: 1233 RVA: 0x0001C240 File Offset: 0x0001A440
		public static void SerializeRotation3D(NetworkWriter writer, Quaternion rot, NetworkTransform.AxisSyncMode mode, NetworkTransform.CompressionSyncMode compression)
		{
			switch (mode)
			{
			case NetworkTransform.AxisSyncMode.AxisX:
				NetworkTransform.WriteAngle(writer, rot.eulerAngles.x, compression);
				break;
			case NetworkTransform.AxisSyncMode.AxisY:
				NetworkTransform.WriteAngle(writer, rot.eulerAngles.y, compression);
				break;
			case NetworkTransform.AxisSyncMode.AxisZ:
				NetworkTransform.WriteAngle(writer, rot.eulerAngles.z, compression);
				break;
			case NetworkTransform.AxisSyncMode.AxisXY:
				NetworkTransform.WriteAngle(writer, rot.eulerAngles.x, compression);
				NetworkTransform.WriteAngle(writer, rot.eulerAngles.y, compression);
				break;
			case NetworkTransform.AxisSyncMode.AxisXZ:
				NetworkTransform.WriteAngle(writer, rot.eulerAngles.x, compression);
				NetworkTransform.WriteAngle(writer, rot.eulerAngles.z, compression);
				break;
			case NetworkTransform.AxisSyncMode.AxisYZ:
				NetworkTransform.WriteAngle(writer, rot.eulerAngles.y, compression);
				NetworkTransform.WriteAngle(writer, rot.eulerAngles.z, compression);
				break;
			case NetworkTransform.AxisSyncMode.AxisXYZ:
				NetworkTransform.WriteAngle(writer, rot.eulerAngles.x, compression);
				NetworkTransform.WriteAngle(writer, rot.eulerAngles.y, compression);
				NetworkTransform.WriteAngle(writer, rot.eulerAngles.z, compression);
				break;
			}
		}

		// Token: 0x060004D2 RID: 1234 RVA: 0x0001C3B1 File Offset: 0x0001A5B1
		public static void SerializeRotation2D(NetworkWriter writer, float rot, NetworkTransform.CompressionSyncMode compression)
		{
			NetworkTransform.WriteAngle(writer, rot, compression);
		}

		// Token: 0x060004D3 RID: 1235 RVA: 0x0001C3BC File Offset: 0x0001A5BC
		public static void SerializeSpin3D(NetworkWriter writer, Vector3 angularVelocity, NetworkTransform.AxisSyncMode mode, NetworkTransform.CompressionSyncMode compression)
		{
			switch (mode)
			{
			case NetworkTransform.AxisSyncMode.AxisX:
				NetworkTransform.WriteAngle(writer, angularVelocity.x, compression);
				break;
			case NetworkTransform.AxisSyncMode.AxisY:
				NetworkTransform.WriteAngle(writer, angularVelocity.y, compression);
				break;
			case NetworkTransform.AxisSyncMode.AxisZ:
				NetworkTransform.WriteAngle(writer, angularVelocity.z, compression);
				break;
			case NetworkTransform.AxisSyncMode.AxisXY:
				NetworkTransform.WriteAngle(writer, angularVelocity.x, compression);
				NetworkTransform.WriteAngle(writer, angularVelocity.y, compression);
				break;
			case NetworkTransform.AxisSyncMode.AxisXZ:
				NetworkTransform.WriteAngle(writer, angularVelocity.x, compression);
				NetworkTransform.WriteAngle(writer, angularVelocity.z, compression);
				break;
			case NetworkTransform.AxisSyncMode.AxisYZ:
				NetworkTransform.WriteAngle(writer, angularVelocity.y, compression);
				NetworkTransform.WriteAngle(writer, angularVelocity.z, compression);
				break;
			case NetworkTransform.AxisSyncMode.AxisXYZ:
				NetworkTransform.WriteAngle(writer, angularVelocity.x, compression);
				NetworkTransform.WriteAngle(writer, angularVelocity.y, compression);
				NetworkTransform.WriteAngle(writer, angularVelocity.z, compression);
				break;
			}
		}

		// Token: 0x060004D4 RID: 1236 RVA: 0x0001C4C5 File Offset: 0x0001A6C5
		public static void SerializeSpin2D(NetworkWriter writer, float angularVelocity, NetworkTransform.CompressionSyncMode compression)
		{
			NetworkTransform.WriteAngle(writer, angularVelocity, compression);
		}

		// Token: 0x060004D5 RID: 1237 RVA: 0x0001C4D0 File Offset: 0x0001A6D0
		public static Vector3 UnserializeVelocity3D(NetworkReader reader, NetworkTransform.CompressionSyncMode compression)
		{
			return reader.ReadVector3();
		}

		// Token: 0x060004D6 RID: 1238 RVA: 0x0001C4EC File Offset: 0x0001A6EC
		public static Vector3 UnserializeVelocity2D(NetworkReader reader, NetworkTransform.CompressionSyncMode compression)
		{
			return reader.ReadVector2();
		}

		// Token: 0x060004D7 RID: 1239 RVA: 0x0001C50C File Offset: 0x0001A70C
		public static Quaternion UnserializeRotation3D(NetworkReader reader, NetworkTransform.AxisSyncMode mode, NetworkTransform.CompressionSyncMode compression)
		{
			Quaternion identity = Quaternion.identity;
			Vector3 zero = Vector3.zero;
			switch (mode)
			{
			case NetworkTransform.AxisSyncMode.AxisX:
				zero.Set(NetworkTransform.ReadAngle(reader, compression), 0f, 0f);
				identity.eulerAngles = zero;
				break;
			case NetworkTransform.AxisSyncMode.AxisY:
				zero.Set(0f, NetworkTransform.ReadAngle(reader, compression), 0f);
				identity.eulerAngles = zero;
				break;
			case NetworkTransform.AxisSyncMode.AxisZ:
				zero.Set(0f, 0f, NetworkTransform.ReadAngle(reader, compression));
				identity.eulerAngles = zero;
				break;
			case NetworkTransform.AxisSyncMode.AxisXY:
				zero.Set(NetworkTransform.ReadAngle(reader, compression), NetworkTransform.ReadAngle(reader, compression), 0f);
				identity.eulerAngles = zero;
				break;
			case NetworkTransform.AxisSyncMode.AxisXZ:
				zero.Set(NetworkTransform.ReadAngle(reader, compression), 0f, NetworkTransform.ReadAngle(reader, compression));
				identity.eulerAngles = zero;
				break;
			case NetworkTransform.AxisSyncMode.AxisYZ:
				zero.Set(0f, NetworkTransform.ReadAngle(reader, compression), NetworkTransform.ReadAngle(reader, compression));
				identity.eulerAngles = zero;
				break;
			case NetworkTransform.AxisSyncMode.AxisXYZ:
				zero.Set(NetworkTransform.ReadAngle(reader, compression), NetworkTransform.ReadAngle(reader, compression), NetworkTransform.ReadAngle(reader, compression));
				identity.eulerAngles = zero;
				break;
			}
			return identity;
		}

		// Token: 0x060004D8 RID: 1240 RVA: 0x0001C66C File Offset: 0x0001A86C
		public static float UnserializeRotation2D(NetworkReader reader, NetworkTransform.CompressionSyncMode compression)
		{
			return NetworkTransform.ReadAngle(reader, compression);
		}

		// Token: 0x060004D9 RID: 1241 RVA: 0x0001C688 File Offset: 0x0001A888
		public static Vector3 UnserializeSpin3D(NetworkReader reader, NetworkTransform.AxisSyncMode mode, NetworkTransform.CompressionSyncMode compression)
		{
			Vector3 zero = Vector3.zero;
			switch (mode)
			{
			case NetworkTransform.AxisSyncMode.AxisX:
				zero.Set(NetworkTransform.ReadAngle(reader, compression), 0f, 0f);
				break;
			case NetworkTransform.AxisSyncMode.AxisY:
				zero.Set(0f, NetworkTransform.ReadAngle(reader, compression), 0f);
				break;
			case NetworkTransform.AxisSyncMode.AxisZ:
				zero.Set(0f, 0f, NetworkTransform.ReadAngle(reader, compression));
				break;
			case NetworkTransform.AxisSyncMode.AxisXY:
				zero.Set(NetworkTransform.ReadAngle(reader, compression), NetworkTransform.ReadAngle(reader, compression), 0f);
				break;
			case NetworkTransform.AxisSyncMode.AxisXZ:
				zero.Set(NetworkTransform.ReadAngle(reader, compression), 0f, NetworkTransform.ReadAngle(reader, compression));
				break;
			case NetworkTransform.AxisSyncMode.AxisYZ:
				zero.Set(0f, NetworkTransform.ReadAngle(reader, compression), NetworkTransform.ReadAngle(reader, compression));
				break;
			case NetworkTransform.AxisSyncMode.AxisXYZ:
				zero.Set(NetworkTransform.ReadAngle(reader, compression), NetworkTransform.ReadAngle(reader, compression), NetworkTransform.ReadAngle(reader, compression));
				break;
			}
			return zero;
		}

		// Token: 0x060004DA RID: 1242 RVA: 0x0001C7AC File Offset: 0x0001A9AC
		public static float UnserializeSpin2D(NetworkReader reader, NetworkTransform.CompressionSyncMode compression)
		{
			return NetworkTransform.ReadAngle(reader, compression);
		}

		// Token: 0x060004DB RID: 1243 RVA: 0x0001C7C8 File Offset: 0x0001A9C8
		public override int GetNetworkChannel()
		{
			return 1;
		}

		// Token: 0x060004DC RID: 1244 RVA: 0x0001C7E0 File Offset: 0x0001A9E0
		public override float GetNetworkSendInterval()
		{
			return this.m_SendInterval;
		}

		// Token: 0x060004DD RID: 1245 RVA: 0x0001C7FB File Offset: 0x0001A9FB
		public override void OnStartAuthority()
		{
			this.m_LastClientSyncTime = 0f;
		}

		// Token: 0x040001F1 RID: 497
		[SerializeField]
		private NetworkTransform.TransformSyncMode m_TransformSyncMode = NetworkTransform.TransformSyncMode.SyncNone;

		// Token: 0x040001F2 RID: 498
		[SerializeField]
		private float m_SendInterval = 0.1f;

		// Token: 0x040001F3 RID: 499
		[SerializeField]
		private NetworkTransform.AxisSyncMode m_SyncRotationAxis = NetworkTransform.AxisSyncMode.AxisXYZ;

		// Token: 0x040001F4 RID: 500
		[SerializeField]
		private NetworkTransform.CompressionSyncMode m_RotationSyncCompression = NetworkTransform.CompressionSyncMode.None;

		// Token: 0x040001F5 RID: 501
		[SerializeField]
		private bool m_SyncSpin;

		// Token: 0x040001F6 RID: 502
		[SerializeField]
		private float m_MovementTheshold = 0.001f;

		// Token: 0x040001F7 RID: 503
		[SerializeField]
		private float m_VelocityThreshold = 0.0001f;

		// Token: 0x040001F8 RID: 504
		[SerializeField]
		private float m_SnapThreshold = 5f;

		// Token: 0x040001F9 RID: 505
		[SerializeField]
		private float m_InterpolateRotation = 1f;

		// Token: 0x040001FA RID: 506
		[SerializeField]
		private float m_InterpolateMovement = 1f;

		// Token: 0x040001FB RID: 507
		[SerializeField]
		private NetworkTransform.ClientMoveCallback3D m_ClientMoveCallback3D;

		// Token: 0x040001FC RID: 508
		[SerializeField]
		private NetworkTransform.ClientMoveCallback2D m_ClientMoveCallback2D;

		// Token: 0x040001FD RID: 509
		private Rigidbody m_RigidBody3D;

		// Token: 0x040001FE RID: 510
		private Rigidbody2D m_RigidBody2D;

		// Token: 0x040001FF RID: 511
		private CharacterController m_CharacterController;

		// Token: 0x04000200 RID: 512
		private bool m_Grounded = true;

		// Token: 0x04000201 RID: 513
		private Vector3 m_TargetSyncPosition;

		// Token: 0x04000202 RID: 514
		private Vector3 m_TargetSyncVelocity;

		// Token: 0x04000203 RID: 515
		private Vector3 m_FixedPosDiff;

		// Token: 0x04000204 RID: 516
		private Quaternion m_TargetSyncRotation3D;

		// Token: 0x04000205 RID: 517
		private Vector3 m_TargetSyncAngularVelocity3D;

		// Token: 0x04000206 RID: 518
		private float m_TargetSyncRotation2D;

		// Token: 0x04000207 RID: 519
		private float m_TargetSyncAngularVelocity2D;

		// Token: 0x04000208 RID: 520
		private float m_LastClientSyncTime;

		// Token: 0x04000209 RID: 521
		private float m_LastClientSendTime;

		// Token: 0x0400020A RID: 522
		private Vector3 m_PrevPosition;

		// Token: 0x0400020B RID: 523
		private Quaternion m_PrevRotation;

		// Token: 0x0400020C RID: 524
		private float m_PrevRotation2D;

		// Token: 0x0400020D RID: 525
		private float m_PrevVelocity;

		// Token: 0x0400020E RID: 526
		private const float k_LocalMovementThreshold = 1E-05f;

		// Token: 0x0400020F RID: 527
		private const float k_LocalRotationThreshold = 1E-05f;

		// Token: 0x04000210 RID: 528
		private const float k_LocalVelocityThreshold = 1E-05f;

		// Token: 0x04000211 RID: 529
		private const float k_MoveAheadRatio = 0.1f;

		// Token: 0x04000212 RID: 530
		private NetworkWriter m_LocalTransformWriter;

		// Token: 0x0200005E RID: 94
		public enum TransformSyncMode
		{
			// Token: 0x04000214 RID: 532
			SyncNone,
			// Token: 0x04000215 RID: 533
			SyncTransform,
			// Token: 0x04000216 RID: 534
			SyncRigidbody2D,
			// Token: 0x04000217 RID: 535
			SyncRigidbody3D,
			// Token: 0x04000218 RID: 536
			SyncCharacterController
		}

		// Token: 0x0200005F RID: 95
		public enum AxisSyncMode
		{
			// Token: 0x0400021A RID: 538
			None,
			// Token: 0x0400021B RID: 539
			AxisX,
			// Token: 0x0400021C RID: 540
			AxisY,
			// Token: 0x0400021D RID: 541
			AxisZ,
			// Token: 0x0400021E RID: 542
			AxisXY,
			// Token: 0x0400021F RID: 543
			AxisXZ,
			// Token: 0x04000220 RID: 544
			AxisYZ,
			// Token: 0x04000221 RID: 545
			AxisXYZ
		}

		// Token: 0x02000060 RID: 96
		public enum CompressionSyncMode
		{
			// Token: 0x04000223 RID: 547
			None,
			// Token: 0x04000224 RID: 548
			Low,
			// Token: 0x04000225 RID: 549
			High
		}

		// Token: 0x02000061 RID: 97
		// (Invoke) Token: 0x060004DF RID: 1247
		public delegate bool ClientMoveCallback3D(ref Vector3 position, ref Vector3 velocity, ref Quaternion rotation);

		// Token: 0x02000062 RID: 98
		// (Invoke) Token: 0x060004E3 RID: 1251
		public delegate bool ClientMoveCallback2D(ref Vector2 position, ref Vector2 velocity, ref float rotation);
	}
}