Gameplay 代码
      |
      | 1) 生成 Blob（附件/RPC/自定义）
      v
  FNetBlobManager::QueueNetObjectAttachment / SendRPC
      |
      | 2) 入队（普通队列 or OOB 急件队列）
      v
  FNetObjectAttachmentSendQueue::ProcessQueue
      |
      | 3) 预序列化
      |    - 能装下：ShrinkWrap（复用序列化结果）
      |    - 装不下：Split（拆成 PartialNetBlob）
      v
  FReplicationWriter::QueueNetObjectAttachments
      |
      | 4) 写入 Packet（可靠/有序由更下层队列保证）
      v
  网络发送 → 网络接收
      |
      v
  反序列化：CreateNetBlob → Deserialize
      |
      v
  FNetBlobHandlerManager::OnNetBlobReceived
      |
      v
  你的 UNetBlobHandler::OnNetBlobReceived（业务逻辑）

// Engine/Source/Runtime/Experimental/Iris/Core/Public/Iris/ReplicationSystem/NetBlob/NetBlob.h

/** Flags that can be set at blob creation time. */enum class ENetBlobFlags : uint32
{
	None = 0,

	/** The blob should be delivered reliably in order with respect to other reliable blobs. Implies Ordered. */
	Reliable = 1U << 0U,

	/** Used for FRawDataNetBlob derived classes to avoid duplicate serialization when splitting large blob. */
	RawDataNetBlob = Reliable << 1U,

	/** Used to indicate that this blob have ObjectReferences that might have to be exported. */
	HasExports = RawDataNetBlob << 1U,

	/** The blob should respect delivery order with respect to other Ordered blobs, including Reliable ones. Unreliable ordered blobs will only be sent once. */
	Ordered = HasExports << 1U,
};

struct FNetBlobCreationInfo
{
	FNetBlobType Type = InvalidNetBlobType;
	ENetBlobFlags Flags = ENetBlobFlags::None;
};

class FNetBlob
{
public:
	// ...
	bool IsReliable() const { return EnumHasAnyFlags(GetCreationInfo().Flags, ENetBlobFlags::Reliable); }
	void AddRef() const { ++RefCount; }
	IRISCORE_API void Release() const;
	int32 GetRefCount() const { return RefCount; }
	// ...
};

class FNetBlob
{
public:
	/** Serialize the blob to a bitstream. */
	virtual void Serialize(FNetSerializationContext& Context) const PURE_VIRTUAL(Serialize,);

	/** Deserialize the blob from a bitstream. */
	virtual void Deserialize(FNetSerializationContext& Context) PURE_VIRTUAL(Deserialize,);

	/** 
	 * Serialize with object reference optimization.
	 * When the blob is associated with an object, this avoids redundantly writing the RefHandle.
	 */
	virtual void SerializeWithObject(FNetSerializationContext& Context, FNetRefHandle RefHandle) const;
	virtual void DeserializeWithObject(FNetSerializationContext& Context, FNetRefHandle RefHandle);
};

class FNetObjectAttachment : public FNetBlob
{
public:
	const FNetObjectReference& GetNetObjectReference() const { return NetObjectReference; }
	const FNetObjectReference& GetTargetObjectReference() const { return TargetObjectReference; }

protected:
	friend class Private::FNetBlobManager;
	FNetObjectReference NetObjectReference;
	FNetObjectReference TargetObjectReference;
};

UCLASS(transient, MinimalApi, Abstract)
class UNetBlobHandler : public UObject, public INetBlobReceiver
{
	GENERATED_BODY()

public:
	TRefCountPtr<FNetBlob> CreateNetBlob(UE::Net::ENetBlobFlags Flags) const;
	UE::Net::FNetBlobType GetNetBlobType() const { return NetBlobType; }

protected:
	IRISCORE_API virtual TRefCountPtr<FNetBlob> CreateNetBlob(const FNetBlobCreationInfo&) const override PURE_VIRTUAL(CreateNetBlob, return nullptr;);
	IRISCORE_API virtual void OnNetBlobReceived(UE::Net::FNetSerializationContext& Context, const TRefCountPtr<FNetBlob>&) override PURE_VIRTUAL(OnNetBlobReceived,);

private:
	UE::Net::FNetBlobType NetBlobType;
};

bool FNetBlobHandlerManager::RegisterHandler(UNetBlobHandler* Handler){
	const FString& ClassName = Handler->GetClass()->GetName();
	const UNetBlobHandlerDefinitions* BlobHandlerDefinitions = GetDefault<UNetBlobHandlerDefinitions>();
	for (const FNetBlobHandlerDefinition& Definition : MakeArrayView(BlobHandlerDefinitions->NetBlobHandlerDefinitions))
	{
		if (Definition.ClassName.ToString() == ClassName)
		{
			const uint32 Index = static_cast<uint32>(&Definition - BlobHandlerDefinitions->NetBlobHandlerDefinitions.GetData());
			Handler->NetBlobType = Index;
			Handlers[Index] = Handler;
			return true;
		}
	}
	return false;
}

void FNetBlob::SerializeCreationInfo(FNetSerializationContext& Context, const FNetBlobCreationInfo& CreationInfo){
	FNetBitStreamWriter* Writer = Context.GetBitStreamWriter();

	Writer->WriteBits((CreationInfo.Type == 0 ? 0U : 1U), 1U);
	if (CreationInfo.Type != 0)
	{
		Writer->WriteBits(CreationInfo.Type, 7U);
	}

	// Retain Reliable flag
	Writer->WriteBits(EnumHasAnyFlags(CreationInfo.Flags, ENetBlobFlags::Reliable) ? 1U : 0U, 1U);
}

// Check if FNetBlob::SerializeCreationInfo needs to use more bits for blob type.checkf(BlobHandlerDefinitions->NetBlobHandlerDefinitions.Num() < 128,
	TEXT("Excessive amount of NetBlobHandlers: %d. This breaks net serialization."),
	BlobHandlerDefinitions->NetBlobHandlerDefinitions.Num());

// 示例：聊天消息 Blob（建议 Reliable）class FChatMessageBlob : public UE::Net::FNetBlob
{
public:
	FString Sender;
	FString Msg;

	// 构造函数：必须正确初始化基类的 CreationInfo
	FChatMessageBlob(const UE::Net::FNetBlobCreationInfo& InCreationInfo)
		: FNetBlob(InCreationInfo)
	{
	}

	virtual void Serialize(UE::Net::FNetSerializationContext& Context) const override
	{
		auto* Writer = Context.GetBitStreamWriter();
		// 注意：实际 API 可能是 WriteString 或需要自己写长度+内容
		UE::Net::WriteString(Writer, Sender);
		UE::Net::WriteString(Writer, Msg);
	}

	virtual void Deserialize(UE::Net::FNetSerializationContext& Context) override
	{
		auto* Reader = Context.GetBitStreamReader();
		UE::Net::ReadString(Reader, Sender);
		UE::Net::ReadString(Reader, Msg);
	}
};

UCLASS()
class UChatMessageBlobHandler : public UNetBlobHandler
{
	GENERATED_BODY()

	virtual TRefCountPtr<UE::Net::FNetBlob> CreateNetBlob(const UE::Net::FNetBlobCreationInfo& Info) const override
	{
		// 使用传入的 CreationInfo 构造 Blobreturn new FChatMessageBlob(Info);
	}

	virtual void OnNetBlobReceived(UE::Net::FNetSerializationContext& Context, const TRefCountPtr<UE::Net::FNetBlob>& Blob) override
	{
		const FChatMessageBlob* Chat = static_cast<const FChatMessageBlob*>(Blob.GetReference());
		UE_LOG(LogTemp, Log, TEXT("Chat from %s: %s"), *Chat->Sender, *Chat->Msg);
		// TODO：交给 UI/聊天系统
	}
};

void FNetBlobManager::Init(FNetBlobManagerInitParams& InitParams){
	BlobHandlerManager.Init();
	// ... 绑定 ReplicationSystem / Connections / NetRefHandleManager / ObjectReferenceCache
	RegisterDefaultHandlers();
	AttachmentSendQueue.Init(this);
}

void FNetBlobManager::RegisterDefaultHandlers(){
	RPCHandler = TStrongObjectPtr<UNetRPCHandler>(NewObject<UNetRPCHandler>());
	RPCHandler->Init(*ReplicationSystem);
	RegisterNetBlobHandler(RPCHandler.Get());

	PartialNetObjectAttachmentHandlerConfig = GetDefault<UPartialNetObjectAttachmentHandlerConfig>();
	PartialNetObjectAttachmentHandler = TStrongObjectPtr<UPartialNetObjectAttachmentHandler>(NewObject<UPartialNetObjectAttachmentHandler>());
	PartialNetObjectAttachmentHandler->Init(InitParams);
	RegisterNetBlobHandler(PartialNetObjectAttachmentHandler.Get());

	NetObjectBlobHandler = TStrongObjectPtr<UNetObjectBlobHandler>(NewObject<UNetObjectBlobHandler>());
	RegisterNetBlobHandler(NetObjectBlobHandler.Get());
}

bool FNetBlobManager::QueueNetObjectAttachment(uint32 ConnectionId, const FNetObjectReference& TargetRef, const TRefCountPtr<FNetObjectAttachment>& Attachment, ENetObjectAttachmentSendPolicyFlags SendFlags){
	FOwnerInfo OwnerInfo;
	OwnerInfo.TargetRef = TargetRef;

	// 解析 Root/SubObject 的 internal index
	bool bCanSendRpc = GetRootObjectAndSubObjectIndicesFromAnyHandle(TargetRef.GetRefHandle(), OwnerInfo.RootObjectIndex, OwnerInfo.SubObjectIndex);
	if (!bCanSendRpc)
	{
		// 如果 TargetRef 有效但没被复制，尝试用 ReplicatedOuter
		OwnerInfo.CallerRef = ObjectReferenceCache->GetReplicatedOuter(TargetRef);
		bCanSendRpc = GetRootObjectAndSubObjectIndicesFromAnyHandle(OwnerInfo.CallerRef.GetRefHandle(), OwnerInfo.RootObjectIndex, OwnerInfo.SubObjectIndex);
	}

	if (!bCanSendRpc)
	{
		// 仍然失败：目标对象不可复制，无法发送return false;
	}

	Attachment->SetNetObjectReference(OwnerInfo.CallerRef, OwnerInfo.TargetRef);
	AttachmentSendQueue.Enqueue(ConnectionId, OwnerInfo.RootObjectIndex, OwnerInfo.SubObjectIndex, Attachment, SendFlags);
	return true;
}

struct FOwnerInfo
{
	FNetObjectReference CallerRef;      // 实际用于路由的"可复制外层对象"引用
	FNetObjectReference TargetRef;      // 原始目标对象引用
	FInternalNetRefIndex RootObjectIndex;   // 根对象的内部索引
	FInternalNetRefIndex SubObjectIndex;    // 子对象的内部索引（如果有）
};

const bool bScheduleUsingOOBAttachmentQueue = EnumHasAnyFlags(SendFlags, ENetObjectAttachmentSendPolicyFlags::ScheduleAsOOB);
FQueue& TargetQueue = bScheduleUsingOOBAttachmentQueue ? ScheduleAsOOBAttachmentQueue : AttachmentQueue;

// NetBlobManager.cpp (ProcessQueue 内部)if (bScheduleUsingOOBAttachmentQueue)
{
	OutConnectionsPendingImmediateSend.Add(ConnectionId);
}

const bool bMulticast = Entry.ConnectionId == 0;
const bool bHasConnectionSpecificSerialization = ReplicationStateDescriptor && EnumHasAnyFlags(ReplicationStateDescriptor->Traits, EReplicationStateTraits::HasConnectionSpecificSerialization);

if (!(bMulticast && bHasConnectionSpecificSerialization) && !PreSerializeAndSplitNetBlob(Entry.ConnectionId, Attachment, PartialNetBlobs, bShouldSendAttachmentsWithObject))
{
	// ...
}

if (bMulticast)
{
	for (uint32 ConnectionId : MakeArrayView(ProcessContext.ConnectionIds))
	{
		if (bHasConnectionSpecificSerialization)
		{
			PartialNetBlobs.Reset();
			PreSerializeAndSplitNetBlob(ConnectionId, Attachment, PartialNetBlobs, bShouldSendAttachmentsWithObject);
			AttachmentsView = MakeArrayView(PartialNetBlobs);
		}
		Connection->ReplicationWriter->QueueNetObjectAttachments(..., AttachmentsView, ...);
	}
}

class UPartialNetObjectAttachmentHandlerConfig : public USequentialPartialNetBlobHandlerConfig
{
public:
	uint32 GetBitCountSplitThreshold() const { return BitCountSplitThreshold; }
	uint32 GetClientUnreliableBitCountSplitThreshold() const { return ClientUnreliableBitCountSplitThreshold; }
	uint32 GetServerUnreliableBitCountSplitThreshold() const { return ServerUnreliableBitCountSplitThreshold; }

private:
	UPROPERTY(Config)
	uint32 BitCountSplitThreshold = (128 + 64)*8;

	UPROPERTY(Config)
	uint32 ClientUnreliableBitCountSplitThreshold = (850)*8;

	UPROPERTY(Config)
	uint32 ServerUnreliableBitCountSplitThreshold = (256)*8;
};

bool UPartialNetObjectAttachmentHandler::PreSerializeAndSplitNetBlob(uint32 ConnectionId, const TRefCountPtr<UE::Net::FNetObjectAttachment>& Blob, TArray<TRefCountPtr<FNetBlob>>& OutPartialBlobs, bool bSerializeWithObject){
	uint32 BitCountSplitThreshold = GetConfig()->GetBitCountSplitThreshold() & ~31U;
	const bool bIsReliable = EnumHasAnyFlags(Blob->GetCreationInfo().Flags, ENetBlobFlags::Reliable);
	if (!bIsReliable)
	{
		BitCountSplitThreshold = (ReplicationSystem->IsServer() ? GetConfig()->GetServerUnreliableBitCountSplitThreshold() : GetConfig()->GetClientUnreliableBitCountSplitThreshold()) & ~31U;
	}

	TArray<uint32> Payload;
	Payload.AddUninitialized(BitCountSplitThreshold/32U);
	FNetBitStreamWriter Writer;
	Writer.InitBytes(Payload.GetData(), Payload.Num()*4U);

	// ... 设置 SerializationContext（含 LocalConnectionId）并序列化 Blob
	Writer.CommitWrites();

	if (Writer.IsOverflown())
	{
		return Super::SplitNetBlob(SerializationContext, /*...*/, OutPartialBlobs);
	}
	else
	{
		FShrinkWrapNetObjectAttachment* ShrinkWrap = new FShrinkWrapNetObjectAttachment(SerializationContext, Blob, MoveTemp(Payload), Writer.GetPosBits());
		OutPartialBlobs.AddDefaulted_GetRef() = ShrinkWrap;
		return true;
	}
}

void FShrinkWrapNetBlob::Deserialize(FNetSerializationContext& Context){
	checkf(false, TEXT("%s"), TEXT("This function should not be called. Contact the networking team."));
}

NetTokenExportsArray = Context.GetExportContext()->GetBatchExports().NetTokensPendingExportInCurrentBatch;
CreationInfo.Flags |= NetTokenExportsArray.Num() ? ENetBlobFlags::HasExports : ENetBlobFlags::None;

if (Private::FNetExportContext* ExportContext = Context.GetExportContext())
{
	const Private::FObjectReferenceCache* ObjectReferenceCache = Context.GetInternalContext()->ObjectReferenceCache;
	ObjectReferenceCache->AddPendingExport(*ExportContext, OriginalBlob->GetNetObjectReference());
	ObjectReferenceCache->AddPendingExport(*ExportContext, OriginalBlob->GetTargetObjectReference());
}

// We need a unique sequence number per split blob to detect out of order sequences.// ... sharing a global sequence number avoids bloating the splitting API ...static std::atomic<uint32> PartialNetBlobGlobalSequenceNumber;

WritePackedUint32(Writer, SequenceNumber);
if (Writer->WriteBool(IsFirstPart()))
{
	WritePackedUint16(Writer, PartCount - 1U);
	SerializeCreationInfo(Context, OriginalCreationInfo);
}

WritePackedUint16(Writer, PayloadBitCount);
Writer->WriteBitStream(Payload.GetData(), 0U, PayloadBitCount);

// We have no idea what the internals of the FNetBlob look like. We must serialize it to a temporary buffer.
TArray<uint32> Payload;
// Trial and error: grow buffer until serialization fits.// ...
Blob->Serialize(SubContext);
// ...
Writer.CommitWrites();
CurrentPayloadBitCount = Writer.GetPosBits();

// Reserve sequence numbers for all parts.
uint32 SequenceNumber = PartialNetBlobGlobalSequenceNumber.fetch_add(PartialBlobCount, std::memory_order_relaxed);

// Copy relevant data into each partial blob.
FPlatformMemory::Memcpy(PartialBlob->Payload.GetData(), SplitParams.Payload + PayloadWordOffset, PartialBlobWordCount*4U);

// PartialNetBlob.cpp 中的扩容逻辑（简化）
uint32 PayloadWordCount = InitialPayloadWordCount;  // 初始大小for (;;)
{
	Payload.SetNumUninitialized(PayloadWordCount);
	Writer.InitBytes(Payload.GetData(), PayloadWordCount * 4U);
	
	Blob->Serialize(SubContext);
	Writer.CommitWrites();
	
	if (!Writer.IsOverflown())
	{
		break;  // 成功，缓冲区够大
	}
	
	// 溢出：扩容重试
	PayloadWordCount *= 2;  // 翻倍策略
	
	if (PayloadWordCount > MaxPayloadWordCount)
	{
		// 超过最大限制，报错
		Context.SetError(GNetError_BitStreamOverflow);
		return false;
	}
}

  原始 Blob
     |
     | Serialize → 临时 Payload（可能需要扩容重试）
     v
  Payload BitCount 已知
     |
     | 计算 PartCount，申请一段连续 SequenceNumber
     v
  循环切块：
     - Part0：写 OriginalCreationInfo + PartCount
     - PartN：只写 Sequence + Payload

const uint32 SequenceNumber = PartialNetBlob->GetSequenceNumber();
const bool bIsFirstPart = PartialNetBlob->IsFirstPart();
const bool bIsReliable = PartialNetBlob->IsReliable();

if (SequenceNumber != NextSequenceSumber || bIsReliable != bIsProcessingReliable)
{
	if (bIsProcessingReliable)
	{
		bIsBrokenSequence = true;
		Context.SetError(NetError_PartialNetBlobSequenceError);
		return;
	}

	if (!bIsFirstPart && SequenceNumber != NextSequenceSumber)
	{
		bIsBrokenSequence = true;
		if (bIsReliable)
		{
			Context.SetError(NetError_PartialNetBlobSequenceError);
		}
		return;
	}
}

if (bIsFirstPart)
{
	NetBlobCreationInfo = PartialNetBlob->GetOriginalCreationInfo();
	// 预分配足够大的 Payload 缓冲
	Payload.SetNumUninitialized((MaxByteCountPerPart*PartCount + 3U)/4U);
	BitWriter.InitBytes(Payload.GetData(), Payload.Num()*4U);
}

BitWriter.WriteBitStream(PartialNetBlob->GetPayload(), 0, PayloadBitCount);

const TRefCountPtr<FNetBlob>& NetBlob = BlobHandler->CreateNetBlob(NetBlobCreationInfo);

// RawDataNetBlob 快路径：直接把 Payload Move 进去if (EnumHasAnyFlags(NetBlob->GetCreationInfo().Flags, ENetBlobFlags::RawDataNetBlob))
{
	FRawDataNetBlob* RawDataNetBlob = static_cast<FRawDataNetBlob*>(NetBlob.GetReference());
	const uint32 PayloadBitCount = BitWriter.GetPosBits();
	BitWriter = FNetBitStreamWriter();
	RawDataNetBlob->SetRawData(MoveTemp(Payload), PayloadBitCount);
}
else
{
	FNetBitStreamReader BitReader;
	BitReader.InitBits(Payload.GetData(), BitWriter.GetPosBits());
	FNetSerializationContext ReadContext = Context.MakeSubContext(&BitReader);
	ReadContext.SetTraceCollector(nullptr);

	NetBlob->Deserialize(ReadContext);

	// Bitstream mismatch?
	if (BitWriter.GetPosBits() != BitReader.GetPosBits())
	{
		Context.SetError(GNetError_BitStreamError);
		return nullptr;
	}
}

static constexpr uint32 MaxUnackedBlobCount = 1024U;

// A single ReplicationRecord supports up to four disjoint sequences...struct FReplicationRecord
{
	FSequence Sequences[4];
};

inline bool FReliableNetBlobQueue::IsSendWindowFull() const{
	return (LastSeq - FirstSeq) >= MaxUnackedBlobCount;
}

for (uint32 Seq = FirstSeq, EndSeq = LastSeq; Seq < EndSeq; ++Seq)
{
	const uint32 Index = Seq & IndexMask;  // 环形缓冲区索引
	
	// IsIndexSent：检查这个序列号是否已经在当前包里写过了
	// 用于避免重复写入（比如重传场景下，同一个包可能包含多段序列）
	if (IsIndexSent(Index)) { continue; }

	FNetBitStreamRollbackScope RollbackScope(*Writer);
	FNetExportRollbackScope ExportRollbackScope(Context);

	// 不连续序列编码：如果当前 Seq 不是上一个写入的 Seq + 1，需要显式写入 Index
	// PrevWrittenSeq：上一次成功写入的序列号，用于判断是否连续
	if (Writer->WriteBool(Seq != PrevWrittenSeq + 1U))
	{
		Writer->WriteBits(Index, IndexBitCount);  // 写入实际的环形索引
	}

	const TRefCountPtr<FNetBlob>& Attachment = Entries[Index].Attachment;
	const bool bHasData = Attachment.GetRefCount() > 0;  // Unreliable 可能已被释放
	if (Writer->WriteBool(bHasData))
	{
		Attachment->SerializeCreationInfo(Context, Attachment->GetCreationInfo());
		Attachment->Serialize(Context);
	}

	// HasMore 标志：告诉接收端是否还有更多数据
	// 这里先写 false，如果后续还有数据会被覆盖
	Writer->WriteBool(false); // HasMore
	
	if (Writer->IsOverflown()) 
	{ 
		ExportRollbackScope.Rollback();  // 回滚导出break;  // RollbackScope 析构时会自动回滚 bitstream
	}
	
	PrevWrittenSeq = Seq;
	MarkIndexSent(Index);
}

FNetBlobCreationInfo CreationInfo;
FNetBlob::DeserializeCreationInfo(Context, CreationInfo);
Blob = BlobReceiver->CreateNetBlob(CreationInfo);
if (!Blob.IsValid())
{
	Context.SetError(GNetError_UnsupportedNetBlob);
	return DeserializedCount;
}

Blob->Deserialize(Context);

  网络包到达
      |
      v
  FReliableNetBlobQueue::Deserialize*
      |
      | 底层可靠队列：负责可靠/有序语义、序列号校验、重传检测
      | 输出：反序列化后的 FNetBlob（可能是 FPartialNetBlob）
      v
  FNetObjectAttachmentReceiveQueue
      |
      | 上层接收队列：负责分片识别、组装、最终分发
      | - 如果是 FPartialNetBlob → 交给 FNetBlobAssembler 组装
      | - 如果是普通 Blob → 直接入队等待处理
      v
  FNetBlobHandlerManager::OnNetBlobReceived

PartialNetBlobType = (InitParams.PartialNetObjectAttachmentHandler ? InitParams.PartialNetObjectAttachmentHandler->GetNetBlobType() : InvalidNetBlobType);

bool FNetObjectAttachmentReceiveQueue::IsPartialNetBlob(const TRefCountPtr<FNetBlob>& Blob) const{
	return Blob.IsValid() && Blob->GetCreationInfo().Type == PartialNetBlobType;
}

if (bIsPartialNetBlob)
{
	TUniquePtr<FNetBlobAssembler>& NetBlobAssembler = bIsBlobReliable ? ReliableNetBlobAssembler : UnreliableNetBlobAssembler;
	if (!NetBlobAssembler.IsValid())
	{
		FNetBlobAssemblerInitParams InitParams;
		InitParams.PartialNetBlobHandlerConfig = PartialNetObjectAttachmentHandler ? PartialNetObjectAttachmentHandler->GetConfig() : nullptr;
		NetBlobAssembler = MakeUnique<FNetBlobAssembler>();
		NetBlobAssembler->Init(InitParams);
	}

	NetBlobAssembler->AddPartialNetBlob(Context, RefHandle, reinterpret_cast<const TRefCountPtr<FPartialNetBlob>&>(NetBlob));
	if (NetBlobAssembler->IsReadyToAssemble() || NetBlobAssembler->IsSequenceBroken())
	{
		if (NetBlobAssembler->IsReadyToAssemble())
		{
			const TRefCountPtr<FNetBlob>& AssembledBlob = NetBlobAssembler->Assemble(Context);
			if (AssembledBlob.IsValid())
			{
				Queue.Enqueue(AssembledBlob);
			}
		}
		NetBlobAssembler.Reset();
	}
}
else
{
	Queue.Enqueue(NetBlob);
}

  反序列化得到 NetBlob
        |
        v
  IsPartialNetBlob ?
     |是                 |否
     v                   v
  Assembler.AddPart     直接入队
     |
     +--> ReadyToAssemble ? --是--> Assemble() 得到原始 Blob --> 入队
     |
     +--> SequenceBroken ? --是--> 报错/丢弃并 Reset

const FNetBlobCreationInfo& CreationInfo = Blob->GetCreationInfo();
UNetBlobHandler* Handler = Handlers[CreationInfo.Type].Get();
return Handler->OnNetBlobReceived(Context, Blob);

发送侧（Gameplay → Packet）

  Gameplay / RPC / Attachment
        |
        v
  FNetBlobManager::QueueNetObjectAttachment / SendRPC
        |
        | ① 进入调度队列（普通 AttachmentQueue 或 OOB ScheduleAsOOBAttachmentQueue）
        v
  FNetBlobManager::FNetObjectAttachmentSendQueue::ProcessQueue
        |
        | ② 预序列化 & 决策：ShrinkWrap 或 Split(FPartialNetBlob...)
        v
  FReplicationWriter::QueueNetObjectAttachments
        |
        | ③ 进入每连接/每对象的发送队列（AttachmentReplication.cpp）
        v
  FNetObjectAttachmentSendQueue
     |                             |
     | Reliable / Ordered          | Unreliable
     |                             |
     v                             v
  FReliableSendQueue               RingQueue(容量受限，满了丢旧的)
   - PreQueue(可很大)              - 只发一次，丢了就算了
   - FReliableNetBlobQueue(窗口=1024)
        |
        | ④ 写入包（Serialize*）并生成 ReplicationRecord
        v
  Packet
        |
        | ⑤ 通过 PacketNotification 回调交付状态
        v
  ProcessPacketDeliveryStatus(Delivered/Lost)
   - Delivered: 释放已确认/推进窗口
   - Lost: 标记未发送 → 触发重传接收侧（Packet → Gameplay）

  Packet
    |
    v
  FReliableNetBlobQueue::Deserialize*
    |
    | ⑥ 先校验序列号，再 Create，再 Deserialize
    v
  得到 NetBlob（可能是 FPartialNetBlob）
    |
    v
  FNetObjectAttachmentReceiveQueue
     | 是 Partial?                     | 否
     v                                vFNetBlobAssembler::AddPartialNetBlob 直接入队
     |
     +--> ReadyToAssemble → Assemble() 得到"原始 Blob"
    |
    v
  FNetBlobHandlerManager::OnNetBlobReceived
    |
    v
  UNetBlobHandler::OnNetBlobReceived（业务）

// ========== 1. 定义 Blob ==========// EnragedStateBlob.hclass FEnragedStateBlob : public UE::Net::FNetObjectAttachment
{
public:
	// 狂暴状态数据
	float DamageMultiplier = 1.0f;
	float SpeedMultiplier = 1.0f;
	float Duration = 0.0f;
	uint8 EnrageLevel = 0;

	FEnragedStateBlob(const UE::Net::FNetBlobCreationInfo& InCreationInfo)
		: FNetObjectAttachment(InCreationInfo)
	{
	}

	virtual void Serialize(UE::Net::FNetSerializationContext& Context) const override
	{
		auto* Writer = Context.GetBitStreamWriter();
		Writer->WriteBits(EnrageLevel, 4);  // 0-15 级狂暴// 使用量化减少带宽
		UE::Net::WriteQuantizedFloat(Writer, DamageMultiplier, 1.0f, 5.0f, 8);  // 1x-5x, 8bit
		UE::Net::WriteQuantizedFloat(Writer, SpeedMultiplier, 1.0f, 3.0f, 8);   // 1x-3x, 8bit
		UE::Net::WriteQuantizedFloat(Writer, Duration, 0.0f, 60.0f, 10);        // 0-60s, 10bit
	}

	virtual void Deserialize(UE::Net::FNetSerializationContext& Context) override
	{
		auto* Reader = Context.GetBitStreamReader();
		EnrageLevel = Reader->ReadBits(4);
		UE::Net::ReadQuantizedFloat(Reader, DamageMultiplier, 1.0f, 5.0f, 8);
		UE::Net::ReadQuantizedFloat(Reader, SpeedMultiplier, 1.0f, 3.0f, 8);
		UE::Net::ReadQuantizedFloat(Reader, Duration, 0.0f, 60.0f, 10);
	}
};

// ========== 2. 定义 Handler ==========// EnragedStateBlobHandler.hUCLASS()
class UEnragedStateBlobHandler : public UNetBlobHandler
{
	GENERATED_BODY()

public:
	// 用于外部获取 Handler 实例
	static UEnragedStateBlobHandler* Get(UReplicationSystem* RepSystem);

protected:
	virtual TRefCountPtr<UE::Net::FNetBlob> CreateNetBlob(
		const UE::Net::FNetBlobCreationInfo& Info) const override
	{
		return new FEnragedStateBlob(Info);
	}

	virtual void OnNetBlobReceived(
		UE::Net::FNetSerializationContext& Context,
		const TRefCountPtr<UE::Net::FNetBlob>& Blob) override
	{
		const FEnragedStateBlob* EnragedBlob = 
			static_cast<const FEnragedStateBlob*>(Blob.GetReference());
		
		// 获取目标对象const FNetObjectAttachment* Attachment = 
			static_cast<const FNetObjectAttachment*>(Blob.GetReference());
		AActor* TargetActor = ResolveNetObjectReference(Attachment->GetTargetObjectReference());
		
		if (AEnemyCharacter* Enemy = Cast<AEnemyCharacter>(TargetActor))
		{
			// 应用狂暴状态
			Enemy->ApplyEnragedState(
				EnragedBlob->EnrageLevel,
				EnragedBlob->DamageMultiplier,
				EnragedBlob->SpeedMultiplier,
				EnragedBlob->Duration
			);
			
			// 播放客户端表现
			Enemy->PlayEnrageVFX();
		}
	}
};

// ========== 3. 服务端发送 ==========// EnemyCharacter.cpp (Server)void AEnemyCharacter::Server_EnterEnragedState(uint8 Level, float Duration){
	// 计算狂暴参数
	float DamageMult = 1.0f + Level * 0.5f;
	float SpeedMult = 1.0f + Level * 0.2f;

	// 创建 Blob
	UE::Net::FNetBlobCreationInfo CreationInfo;
	CreationInfo.Flags = UE::Net::ENetBlobFlags::Reliable;  // 关键状态，必须可靠
	
	TRefCountPtr<FEnragedStateBlob> Blob = new FEnragedStateBlob(CreationInfo);
	Blob->EnrageLevel = Level;
	Blob->DamageMultiplier = DamageMult;
	Blob->SpeedMultiplier = SpeedMult;
	Blob->Duration = Duration;

	// 获取 NetBlobManager 并发送
	if (UReplicationSystem* RepSystem = GetReplicationSystem())
	{
		FNetBlobManager* BlobManager = RepSystem->GetNetBlobManager();
		FNetObjectReference TargetRef = RepSystem->GetNetObjectReference(this);
		
		// 多播给所有连接（ConnectionId = 0）// 使用 ScheduleAsOOB 让状态尽快送达
		BlobManager->QueueNetObjectAttachment(
			0,  // 0 = 多播
			TargetRef,
			Blob,
			ENetObjectAttachmentSendPolicyFlags::ScheduleAsOOB
		);
	}
}

; DefaultEngine.ini[/Script/IrisCore.NetBlobHandlerDefinitions]
+NetBlobHandlerDefinitions=(ClassName="EnragedStateBlobHandler")

// Helper class for stateless data...// Things like splitting and assembling have optimized code paths for this type of blob.class FRawDataNetBlob : public FNetBlob
{
	IRISCORE_API void SetRawData(TArray<uint32>&& RawData, uint32 RawDataBitCount);
	TArrayView<const uint32> GetRawData() const;
	uint32 GetRawDataBitCount() const;
};

; DefaultEngine.ini; 让 NetBlobHandlerManager 能找到你的 Handler（注意：顺序会影响 Type 分配）[/Script/IrisCore.NetBlobHandlerDefinitions]
+NetBlobHandlerDefinitions=(ClassName="ChatMessageBlobHandler")
+NetBlobHandlerDefinitions=(ClassName="EnragedStateBlobHandler")

// 在游戏模块初始化时void FMyGameModule::StartupModule(){
	// 获取 Definitions 并添加
	UNetBlobHandlerDefinitions* Definitions = GetMutableDefault<UNetBlobHandlerDefinitions>();
	
	FNetBlobHandlerDefinition ChatDef;
	ChatDef.ClassName = FName(TEXT("ChatMessageBlobHandler"));
	Definitions->NetBlobHandlerDefinitions.AddUnique(ChatDef);
}