BeardedManStudios.Network.NetworkedMonoBehavior.AuthoritativeFrameHistory.FinishFrame C# (CSharp) Метод

			private Vector3 FinishFrame(NetWorker owningNetworker, AuthoritativeFrameType type, Vector3 currentValue, byte serverFrame, Vector3 serverValue)
			{
				bool frameFound = false;
				int iter = 0;
				Vector3 pos = currentValue;
				switch (type)
				{
					case AuthoritativeFrameType.Position:
						if (_posLastFrame != serverFrame)
						{
							_posLastFrame = serverFrame;
							_posTimeStamp = Time.time;
							
							if (_positionFrameHistory.Count > 0)
							{
								for (int i = _positionFrameHistory.Count - 1; i >= 0; --i)
								{
									if (_positionFrameHistory[i].Frame == serverFrame)
									{
										frameFound = true;
										iter = i;
										break;
									}
								}

								if (frameFound)
								{
									_positionFrameHistory.RemoveRange(0, iter);

									_positionFrameHistory[0].FrameActualValue = serverValue;
									_positionFrameHistory[0].FrameValue = Vector3.zero;

									if (_positionFrameHistory.Count > 1)
									{
										_positionFrameHistory[1].FramePrevious = _positionFrameHistory[0].FrameActualValue;
										_positionFrameHistory[1].UpdateDelta();
									}

									pos = serverValue;
									for (int i = 0; i < _positionFrameHistory.Count; ++i)
										pos += _positionFrameHistory[i].FrameValue; //Get the delta distance
								}
							}

							currentValue = pos;
						}
						else
						{
							if ((Time.time - _posTimeStamp) * 1000 > owningNetworker.PreviousServerPing + 100)
							{
								_posTimeStamp = Time.time;
								if (Vector3.Distance(currentValue, serverValue) > 0.1f)
								{
									currentValue = serverValue;
									_positionFrameHistory.Clear();
								}
							}
						}
						break;
					case AuthoritativeFrameType.Rotation:
						if (_rotLastFrame != serverFrame)
						{
							_rotLastFrame = serverFrame;
							_rotTimeStamp = Time.time;

							if (_rotationFrameHistory.Count > 0)
							{
								for (int i = _rotationFrameHistory.Count - 1; i >= 0; --i)
								{
									if (_rotationFrameHistory[i].Frame == serverFrame)
									{
										frameFound = true;
										iter = i;
										break;
									}
								}

								if (frameFound)
								{
									_rotationFrameHistory.RemoveRange(0, iter);

									_rotationFrameHistory[0].FrameActualValue = serverValue;
									_rotationFrameHistory[0].FrameValue = Vector3.zero;

									if (_rotationFrameHistory.Count > 1)
									{
										_rotationFrameHistory[1].FramePrevious = _rotationFrameHistory[0].FrameActualValue;
										_rotationFrameHistory[1].UpdateDelta();
									}

									pos = serverValue;
									for (int i = 0; i < _rotationFrameHistory.Count; ++i)
										pos += _rotationFrameHistory[i].FrameValue; //Get the delta distance
								}
							}

							currentValue = pos;
						}
						else
						{
							if ((Time.time - _rotTimeStamp) * 1000 > owningNetworker.PreviousServerPing + 100)
							{
								_rotTimeStamp = Time.time;
								if (Vector3.Distance(currentValue, serverValue) > 0.1f)
								{
									currentValue = serverValue;
									_rotationFrameHistory.Clear();
								}
							}
						}
						break;
					case AuthoritativeFrameType.Scale:
						if (_scaLastFrame != serverFrame)
						{
							_scaLastFrame = serverFrame;
							_scaTimeStamp = Time.time;

							if (_scaleFrameHistory.Count > 0)
							{
								for (int i = _scaleFrameHistory.Count - 1; i >= 0; --i)
								{
									if (_scaleFrameHistory[i].Frame == serverFrame)
									{
										frameFound = true;
										iter = i;
										break;
									}
								}

								if (frameFound)
								{
									_scaleFrameHistory.RemoveRange(0, iter);

									_scaleFrameHistory[0].FrameActualValue = serverValue;
									_scaleFrameHistory[0].FrameValue = Vector3.zero;

									if (_scaleFrameHistory.Count > 1)
									{
										_scaleFrameHistory[1].FramePrevious = _scaleFrameHistory[0].FrameActualValue;
										_scaleFrameHistory[1].UpdateDelta();
									}

									pos = serverValue;
									for (int i = 0; i < _scaleFrameHistory.Count; ++i)
										pos += _scaleFrameHistory[i].FrameValue; //Get the delta distance
								}
							}

							currentValue = pos;
						}
						else
						{
							if ((Time.time - _scaTimeStamp) * 1000 > owningNetworker.PreviousServerPing + 100)
							{
								_scaTimeStamp = Time.time;
								if (Vector3.Distance(currentValue, serverValue) > 0.1f)
								{
									currentValue = serverValue;
									_scaleFrameHistory.Clear();
								}
							}
						}
						break;
				}

				return currentValue;
			}