ServerConnection->PreTickDispatch();
ServerConnection->PostTickDispatch();

for ( int32 i=0; i < ClientConnections.Num(); i++ )
{
	...
    
	Connection->ExecuteOnAllDormantReplicators(ValidateFunction);
}

void UNetConnection::InitBase(...)
{
	// Connection 식별 및 기본 설정
	Driver = InDriver;
	SetConnectionHandle(...);
	SetConnectionState(InState);
	URL = InURL;
    
    ...

	// 전송을 위한 기반 구성
	InitChannelData();      // Channel 생성
	InitHandler();          // 패킷 처리 파이프라인
	MaxPacket = InMaxPacket;
	PacketOverhead = InPacketOverhead;
    
    ...

	// 네트워크 객체 식별 및 매핑
	PackageMap = NewObject<UPackageMapClient>(this, PackageMapClass);
	PackageMap->Initialize(this, Driver->GuidCache);

	...

	// Iris Replication 연결
	if (UReplicationSystem* ReplicationSystem = Driver->GetReplicationSystem())
	{
		ReplicationSystem->AddConnection(...);
		ReplicationSystem->SetConnectionUserData(..., this);
	}
}

void UNetConnection::Tick(float DeltaSeconds)
{
	SCOPE_CYCLE_COUNTER(Stat_NetConnectionTick);

	AssertValid();

	// 1. 프레임 시간 및 Tick Rate 계산
	const double CurrentRealtimeSeconds = FPlatformTime::Seconds();

	...

	if (FrameTime < MinNetFrameTime)
	{
		return; // Tick Rate 제한 (과도한 네트워크 처리 방지)
	}

	...

	// 2. 통계 및 상태 업데이트
	if ( CurrentRealtimeSeconds - StatUpdateTime > StatPeriod )
	{
		...
	}

	// 3. 연결 종료 / 타임아웃 처리
	if (bConnectionPendingCloseDueToSocketSendFailure)
	{
		Close(ENetCloseResult::SocketSendFailure);
		return;
	}

	...

	if (bReceiveTimedOut || bGracefulCloseTimedOut)
	{
		HandleConnectionTimeout(Error);
		return;
	}
	else
	{
		// 4. Channel 업데이트
        // 이 단계에서 ActorChannel / DataStreamChannel이 처리되며, 
        // 리플리케이션 결과가 실제 전송 가능한 형태(Bunch / DataStream)로 준비됨.
		checkf(ChannelsToTick.Num() <= OpenChannels.Num(), ...);

		// ActorChannel / DataStreamChannel Tick 수행
		for (int32 i = ChannelsToTick.Num()-1; i>=0; i--)
		{
			ChannelsToTick[i]->Tick();

			if (ChannelsToTick[i]->CanStopTicking())
			{
				ChannelsToTick.RemoveAt(i);
			}
		}

		// 아직 처리되지 않은 ActorChannel Bunch 처리
		for (auto ProcessingActorMapIter = KeepProcessingActorChannelBunchesMap.CreateIterator(); ProcessingActorMapIter; ++ProcessingActorMapIter)
		{
			...
			if (CurChannel->ProcessQueuedBunches())
			{
				CurChannel->ConditionalCleanUp(false, CurChannel->QueuedCloseReason);
			}
			...
		}

		// Channel 종료 처리
		TryClosePendingGracefulClose();

		// Connection 종료 조건 체크
		if (Channels[0] == nullptr && ...)
		{
			SetConnectionState(EConnectionState::USOCK_Closed);
		}
	}

	// 5. 패킷 송신 트리거
	if ( TimeSensitive || (Driver->GetElapsedTime() - LastSendTime) > Driver->KeepAliveTime)
	{
		bool bHandlerHandshakeComplete = !Handler.IsValid() || Handler->IsFullyInitialized();

		// 실제 패킷 송신 시작 지점
		if (bHandlerHandshakeComplete && HasReceivedClientPacket())
		{
			FlushNet(); // ← Replication 결과가 패킷으로 전송됨
		}
	}


	// 6. PacketHandler 처리 (중간 계층)
	if (Handler.IsValid())
	{
		Handler->Tick(FrameTime);

		// 재전송 패킷 처리 (Reliability 보장)
		BufferedPacket* ResendPacket = Handler->GetQueuedRawPacket();

		while (ResendPacket != nullptr)
		{
			LowLevelSend(ResendPacket->Data, ResendPacket->CountBits, ResendPacket->Traits);
			ResendPacket = Handler->GetQueuedRawPacket();
		}

		// 일반 큐 패킷 전송
		BufferedPacket* QueuedPacket = Handler->GetQueuedPacket();

		while(QueuedPacket != nullptr)
		{
			LowLevelSend(QueuedPacket->Data, QueuedPacket->CountBits, QueuedPacket->Traits);
			delete QueuedPacket;
			QueuedPacket = Handler->GetQueuedPacket();
		}
	}
}

void UNetConnection::FlushNet(bool bIgnoreSimulation)
{
	// 전송 준비 상태 검증
	check(Driver);
	ValidateSendBuffer();

	LastEnd = FBitWriterMark();
	TimeSensitive = 0;

	// 1. 전송 필요 여부 판단
	if (SendBuffer.GetNumBits() || HasDirtyAcks || ...)
	{
		// Handshake 완료 전이면 전송 차단 (보안/동기화)
		if (!HasReceivedClientPacket() && ...)
		{
			Close(ENetCloseResult::PrematureSend);
			InitSendBuffer();
			return;
		}

		FOutPacketTraits Traits;

		// 2. 패킷 헤더 구성
		if (SendBuffer.GetNumBits() == 0)
		{
			// KeepAlive 패킷 생성
			WriteBitsToSendBuffer(NULL, 0);
			Traits.bIsKeepAlive = true;
		}

		// PacketHandler 처리 (암호화 / 압축 등)
		if (Handler.IsValid())
		{
			Handler->OutgoingHigh(SendBuffer);
		}

		const double PacketSentTimeInS = FPlatformTime::Seconds();

		// 패킷 종료 비트 기록
		SendBuffer.WriteBit(1);

		// ACK / Sequence / Header 작성
		if (!IsInternalAck())
		{
			WritePacketHeader(SendBuffer);
			WriteFinalPacketInfo(SendBuffer, PacketSentTimeInS);
		}

		ValidateSendBuffer();

		// 3. 실제 전송 
		if (Driver->IsNetResourceValid())
		{
			// 실제 소켓 송신
			LowLevelSend(SendBuffer.GetData(), SendBuffer.GetNumBits(), Traits);
		}


		// 4. 통계 및 상태 업데이트
		...
		++OutPacketId;
		++OutPackets;
		Driver->OutPackets++;

		LastSendTime = Driver->GetElapsedTime();

		...

		bFlushedNetThisFrame = true;

		// 5. 버퍼 초기화
		InitSendBuffer();
	}
}

void UNetConnection::ReceivedRawPacket( void* InData, int32 Count )
{
	using namespace UE::Net;

	...

	uint8* Data = (uint8*)InData;

	// PacketHandler 처리 (암호화 해제 / 핸드셰이크 / 검증)
	if (Handler.IsValid())
	{
		FReceivedPacketView PacketView;
		PacketView.DataView = {Data, Count, ECountUnits::Bytes};

		EIncomingResult IncomingResult = Handler->Incoming(PacketView);

		if (IncomingResult == EIncomingResult::Success)
		{
			// Handler 처리 후 실제 유효 데이터로 갱신
			Count = PacketView.DataView.NumBytes();

			if (Count > 0)
			{
				Data = PacketView.DataView.GetMutableData();
			}
			else
			{
				return; // Handler에서 완전히 소비된 패킷
			}
		}
		else
		{
			// 패킷 처리 실패 → 연결 종료 가능
			UE_LOG(LogNet, Warning, TEXT("Packet failed PacketHandler processing."));
			Close(...);
			return;
		}

		// Handler 초기화 이전 패킷 무시 (Handshake 미완료 상태)
		if (!Handler->IsFullyInitialized())
		{
			UE_LOG(LogNet, Warning, TEXT("PacketHandler not fully initialized."));
			return;
		}
	}

	...

	// Raw Byte → BitReader 변환
	if (Count > 0)
	{
		uint8 LastByte = Data[Count-1];

		if (LastByte != 0)
		{
			int32 BitSize = (Count * 8) - 1;

			// 실제 유효 Bit 길이 계산
			while (!(LastByte & 0x80))
			{
				LastByte *= 2;
				BitSize--;
			}

			FBitReader Reader(Data, BitSize);

			...

			// PacketHandler 후처리 (High-level)
			if (Handler.IsValid())
			{
				Handler->IncomingHigh(Reader);
			}

			// 4. 실제 패킷 파싱 시작
			if (Reader.GetBitsLeft() > 0)
			{
				ReceivedPacket(Reader); // ← Header / ACK / Bunch 파싱

				// 패킷 순서 보정
				FlushPacketOrderCache();
			}
		}
		else
		{
			// 잘못된 패킷 (마지막 바이트 0)
			UE_LOG(LogNet, Warning, TEXT("Received packet with 0's in last byte"));
			HandleNetResultOrClose(...);
		}
	}
	else 
	{
		// 잘못된 패킷 (크기 0)
		UE_LOG(LogNet, Warning, TEXT("Received zero-size packet"));
		HandleNetResultOrClose(...);
	}
}