Writing a Metadata Replicator module

Atoms Behaviour Module

// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
#pragma once

#include <Atoms/BehaviourModule.h>

class UWorld;
class AActor;
class UAgentCollisionComponent;

class CustomMetadataReplicatorModule : public Atoms::BehaviourModule
{
public:

	CustomMetadataReplicatorModule ();

	virtual ~CustomMetadataReplicatorModule ();

	void initSimulation(Atoms::AgentGroup* agentGroup)  override;

	void agentsCreated(const std::vector<Atoms::Agent *>& agents, Atoms::AgentGroup* agentGroup = nullptr) override;

	void initFrame(const std::vector<Atoms::Agent*>& agents, Atoms::AgentGroup* agentGroup = nullptr) override;

	static Atoms::BehaviourModule* creator(const std::string& parameter);

	void setWorld(UWorld* world) { m_world = world; }

	void setMetadataReplicatorComponent(class UCustomMetadataReplicatorComponent* component) { m_replicatorComponent = component; }

	UCustomMetadataReplicatorComponent* GetReplicatorComponent();

	void AdvanceCounter(size_t TypeId, size_t& dataCounter) const;

	size_t GetDataOffset(size_t TypeId) const;

private:

	UWorld* m_world;

	class UCustomMetadataReplicatorComponent* m_replicatorComponent;

	double elapsedTime;

	bool serverStarted;

};

#include "CustomMetadataReplicatorModule.h"
#include "AtomsConversions.h"
#include "Actors/AtomsAgentGroup.h"
#include "CustomMetadataReplicatorComponent.h"
#include "Components/AgentCollisionComponent.h"
#include "GameFramework/GameStateBase.h"
#include <AtomsCore/Metadata/Vector2Metadata.h>
#include <AtomsCore/Metadata/Vector2fMetadata.h>
#include <AtomsCore/Metadata/Vector3Metadata.h>
#include <AtomsCore/Metadata/Vector3fMetadata.h>
#include <AtomsCore/Metadata/Vector4Metadata.h>
#include <AtomsCore/Metadata/Vector4fMetadata.h>
#include <AtomsCore/Metadata/Vector3ArrayMetadata.h>
#include <AtomsCore/Metadata/Vector2fArrayMetadata.h>
#include <AtomsCore/Metadata/Vector3fArrayMetadata.h>
#include <AtomsCore/Metadata/Vector4fArrayMetadata.h>
#include <AtomsCore/Metadata/Vector4ArrayMetadata.h>
#include <AtomsCore/Metadata/MatrixMetadata.h>
#include <AtomsCore/Metadata/MatrixfMetadata.h>
#include <AtomsCore/Metadata/MatrixArrayMetadata.h>
#include <AtomsCore/Metadata/MatrixfArrayMetadata.h>
#include <AtomsCore/Metadata/QuaternionMetadata.h>
#include <AtomsCore/Metadata/QuaternionfMetadata.h>
#include <AtomsCore/Metadata/QuaternionArrayMetadata.h>
#include <AtomsCore/Metadata/QuaternionfArrayMetadata.h>
#include <AtomsCore/Metadata/EulerMetadata.h>
#include <AtomsCore/Metadata/EulerfMetadata.h>
#include <AtomsCore/Metadata/EulerArrayMetadata.h>
#include <AtomsCore/Metadata/EulerfArrayMetadata.h>
#include <AtomsCore/Metadata/IntMetadata.h>
#include <AtomsCore/Metadata/IntArrayMetadata.h>
#include <AtomsCore/Metadata/DoubleMetadata.h>
#include <AtomsCore/Metadata/DoubleArrayMetadata.h>
#include <AtomsCore/Metadata/FloatMetadata.h>
#include <AtomsCore/Metadata/FloatArrayMetadata.h>
#include <AtomsCore/Metadata/MapMetadata.h>
#include <AtomsCore/Metadata/BoolMetadata.h>
#include <AtomsCore/Metadata/BoolArrayMetadata.h>
#include <AtomsCore/Metadata/StringMetadata.h>
#include <AtomsCore/Metadata/StringArrayMetadata.h>
#include <AtomsCore/Metadata/Box3Metadata.h>
#include <AtomsCore/Metadata/ArrayMetadata.h>
#include <AtomsUtils/TaskScheduler.h>
#include <Atoms/Agent.h>
#include <Atoms/AgentGroup.h>
#include <Atoms/GlobalNames.h>
#include <AtomsUtils/Memory.h>

CustomMetadataReplicatorModule::CustomMetadataReplicatorModule() : Atoms::BehaviourModule(),
m_world(nullptr),
m_replicatorComponent(nullptr),
serverStarted(false)
{
	AtomsCore::StringMetadata metadataNames;
	addAttribute("MetadataName", &metadataNames);

	AtomsCore::BoolMetadata enable(false);
	addAttribute("EnableReplication", &enable, true);
}

CustomMetadataReplicatorModule::~CustomMetadataReplicatorModule()
{

}

void CustomMetadataReplicatorModule::initSimulation(Atoms::AgentGroup* agentGroup)
{
	elapsedTime = 0.0;
}


void CustomMetadataReplicatorModule::agentsCreated(const std::vector<Atoms::Agent *>& agents, Atoms::AgentGroup* agentGroup)
{
	if (!m_replicatorComponent)
		return;
	for (auto* agent : agents)
	{
		AtomsCore::BoolMetadata hasAutority(m_replicatorComponent->GetOwnerRole() == ROLE_Authority);
		agent->metadata().addEntry("hasAutority", &hasAutority);
	}
}

size_t CustomMetadataReplicatorModule::GetDataOffset(size_t TypeId) const
{
	switch (TypeId)
	{
	case kMetadataBoolTypeId:
	case kMetadataStringTypeId:
	case kMetadataIntTypeId:
	case kMetadataDoubleTypeId:
	case kMetadataFloatTypeId:
	{
		return 1;
		break;
	}
	case kMetadataVector3fTypeId:
	case kMetadataVector3TypeId:
	case kMetadataEulerfTypeId:
	case kMetadataEulerTypeId:
	{
		return 3;
		break;
	}
	case kMetadataVector4fTypeId:
	case kMetadataVector4TypeId:
	case kMetadataQuaternionfTypeId:
	case kMetadataQuaternionTypeId:
	{
		return 4;
		break;
	}
	case kMetadataMatrixfTypeId:
	{
		return 16;
		break;
	}
	default:
		break;
	}

	return 0;
}

void CustomMetadataReplicatorModule::AdvanceCounter(size_t TypeId, size_t& dataCounter) const
{
	dataCounter += GetDataOffset(TypeId);
}

void CustomMetadataReplicatorModule::initFrame(const std::vector<Atoms::Agent*>& agents, Atoms::AgentGroup* agentGroup)
{
	if (!m_replicatorComponent)
		return;

	auto metadataName = attributes().getTypedEntry<AtomsCore::StringMetadata>("MetadataName");
	if (!metadataName)
		return;

	auto metadataInterpolation = attributes().getTypedEntry<AtomsCore::BoolMetadata>("MetadataInterpolation");
	if (!metadataInterpolation)
		return;

	auto enable = attributes().getTypedEntry<AtomsCore::BoolMetadata>("EnableReplication")->value();
	auto enableOverride = attributes().getTypedEntry<AtomsCore::MapMetadata>("EnableReplication_override");
	const std::string enableMetaName = name() + "@EnableReplication";
	bool interpolation = metadataInterpolation->value();
	double currentSeconds = agentGroup->simulationTime().seconds();
	
	if (m_replicatorComponent->GetOwnerRole() == ROLE_Authority)
	{
		if (!m_replicatorComponent->EnableReplication)
			return;

		if (m_replicatorComponent->UseRpc)
		{
			if (currentSeconds - elapsedTime < m_replicatorComponent->UpdateTime)
			{
				return;
			}
		}
		elapsedTime = agentGroup->simulationTime().seconds();

		FMetadataReplicatorState State;
		State.SimulationTime = agentGroup->simulationTime().time();
		bool typeIdFound = false;
		for (size_t i = 0; i < agents.size(); ++i)
		{
			auto* agent = agents[i];
			if (!agent)
				continue;
			auto CurrentData = agent->metadata().getEntry(metadataName->get());
			if (!CurrentData)
				continue;

			if (!getAttributePerAgent(enable, enableOverride.get(), agent->groupIdStr()->value(), agent->metadata(), enableMetaName))
				continue;

			if (!typeIdFound)
				State.TypeId = CurrentData->typeId();

			if (State.TypeId != CurrentData->typeId())
				continue;

			if (!agent->groupId())
				continue;

			State.Ids.Add(agent->groupId()->value());

			switch (CurrentData->typeId())
			{
			case kMetadataBoolTypeId:
			{
				State.ValueMetadata.Add(std::static_pointer_cast<AtomsCore::BoolMetadata>(CurrentData)->get() ? 1.0 : 0.0);
				break;
			}
			case kMetadataIntTypeId:
			{
				State.ValueMetadata.Add(std::static_pointer_cast<AtomsCore::IntMetadata>(CurrentData)->get());
				break;
			}
			case kMetadataFloatTypeId:
			{
				State.ValueMetadata.Add(std::static_pointer_cast<AtomsCore::FloatMetadata>(CurrentData)->get());
				break;
			}
			case kMetadataDoubleTypeId:
			{
				State.ValueMetadata.Add(std::static_pointer_cast<AtomsCore::DoubleMetadata>(CurrentData)->get());
				break;
			}
			case kMetadataStringTypeId:
			{
				State.StringMetadata.Add(std::static_pointer_cast<AtomsCore::StringMetadata>(CurrentData)->get().c_str());
				break;
			}
			case kMetadataVector2fTypeId:
			{
				auto value = std::static_pointer_cast<AtomsCore::Vector2fMetadata>(CurrentData)->get();
				State.ValueMetadata.Add(value.x);
				State.ValueMetadata.Add(value.y);
				break;
			}
			case kMetadataVector2TypeId:
			{
				auto value = std::static_pointer_cast<AtomsCore::Vector2Metadata>(CurrentData)->get();
				State.ValueMetadata.Add(value.x);
				State.ValueMetadata.Add(value.y);
				break;
			}
			case kMetadataVector3fTypeId:
			{
				auto value = std::static_pointer_cast<AtomsCore::Vector3fMetadata>(CurrentData)->get();
				State.ValueMetadata.Add(value.x);
				State.ValueMetadata.Add(value.y);
				State.ValueMetadata.Add(value.z);
				break;
			}
			case kMetadataVector3TypeId:
			{
				auto value = std::static_pointer_cast<AtomsCore::Vector3Metadata>(CurrentData)->get();
				State.ValueMetadata.Add(value.x);
				State.ValueMetadata.Add(value.y);
				State.ValueMetadata.Add(value.z);
				break;
			}
			case kMetadataVector4fTypeId:
			{
				auto value = std::static_pointer_cast<AtomsCore::Vector4fMetadata>(CurrentData)->get();
				State.ValueMetadata.Add(value.x);
				State.ValueMetadata.Add(value.y);
				State.ValueMetadata.Add(value.z);
				State.ValueMetadata.Add(value.w);
				break;
			}
			case kMetadataVector4TypeId:
			{
				auto value = std::static_pointer_cast<AtomsCore::Vector4Metadata>(CurrentData)->get();
				State.ValueMetadata.Add(value.x);
				State.ValueMetadata.Add(value.y);
				State.ValueMetadata.Add(value.z);
				State.ValueMetadata.Add(value.w);
				break;
			}
			case kMetadataMatrixfTypeId:
			{
				auto value = std::static_pointer_cast<AtomsCore::MatrixfMetadata>(CurrentData)->get();
				State.ValueMetadata.Add(value[0][0]);
				State.ValueMetadata.Add(value[0][1]);
				State.ValueMetadata.Add(value[0][2]);
				State.ValueMetadata.Add(value[0][3]);
				State.ValueMetadata.Add(value[1][0]);
				State.ValueMetadata.Add(value[1][1]);
				State.ValueMetadata.Add(value[1][2]);
				State.ValueMetadata.Add(value[1][3]);
				State.ValueMetadata.Add(value[2][0]);
				State.ValueMetadata.Add(value[2][1]);
				State.ValueMetadata.Add(value[2][2]);
				State.ValueMetadata.Add(value[2][3]);
				State.ValueMetadata.Add(value[3][0]);
				State.ValueMetadata.Add(value[3][1]);
				State.ValueMetadata.Add(value[3][2]);
				State.ValueMetadata.Add(value[3][3]);
				break;
			}
			case kMetadataMatrixTypeId:
			{
				auto value = std::static_pointer_cast<AtomsCore::MatrixMetadata>(CurrentData)->get();
				State.ValueMetadata.Add(value[0][0]);
				State.ValueMetadata.Add(value[0][1]);
				State.ValueMetadata.Add(value[0][2]);
				State.ValueMetadata.Add(value[0][3]);
				State.ValueMetadata.Add(value[1][0]);
				State.ValueMetadata.Add(value[1][1]);
				State.ValueMetadata.Add(value[1][2]);
				State.ValueMetadata.Add(value[1][3]);
				State.ValueMetadata.Add(value[2][0]);
				State.ValueMetadata.Add(value[2][1]);
				State.ValueMetadata.Add(value[2][2]);
				State.ValueMetadata.Add(value[2][3]);
				State.ValueMetadata.Add(value[3][0]);
				State.ValueMetadata.Add(value[3][1]);
				State.ValueMetadata.Add(value[3][2]);
				State.ValueMetadata.Add(value[3][3]);
				break;
			}
			case kMetadataEulerfTypeId:
			{
				auto value = std::static_pointer_cast<AtomsCore::EulerfMetadata>(CurrentData)->get();
				State.ValueMetadata.Add(value.x);
				State.ValueMetadata.Add(value.y);
				State.ValueMetadata.Add(value.z);
				break;
			}
			case kMetadataEulerTypeId:
			{
				auto value = std::static_pointer_cast<AtomsCore::EulerMetadata>(CurrentData)->get();
				State.ValueMetadata.Add(value.x);
				State.ValueMetadata.Add(value.y);
				State.ValueMetadata.Add(value.z);
				break;
			}
			case kMetadataQuaternionfTypeId:
			{
				auto value = std::static_pointer_cast<AtomsCore::QuaternionfMetadata>(CurrentData)->get();
				State.ValueMetadata.Add(value.v.x);
				State.ValueMetadata.Add(value.v.y);
				State.ValueMetadata.Add(value.v.z);
				State.ValueMetadata.Add(value.r);
				break;
			}
			case kMetadataQuaternionTypeId:
			{
				auto value = std::static_pointer_cast<AtomsCore::QuaternionMetadata>(CurrentData)->get();
				State.ValueMetadata.Add(value.v.x);
				State.ValueMetadata.Add(value.v.y);
				State.ValueMetadata.Add(value.v.z);
				State.ValueMetadata.Add(value.r);
				break;
			}
			default:
				break;
			}

		}

		if (m_replicatorComponent->EnableReplication && m_replicatorComponent->UseRpc)
		{
			if (m_replicatorComponent->UseReliableRpc)
				m_replicatorComponent->UpdatedMetadata(State);	
			else
				m_replicatorComponent->UnreliableUpdatedMetadata(State);
		}
		else
		{
			m_replicatorComponent->ReplicatedMetadata = State;
		}
	}
	else if (m_replicatorComponent->ClientReplicatedData.Num() > 1)
	{
		auto Actor = m_replicatorComponent->GetOwner();
		if (!Actor)
			return;

		UAgentCollisionComponent* CollisionComponent = nullptr;
#if ENGINE_MINOR_VERSION < 24
		auto ExistingRagdollComponents = Actor->GetComponentsByClass(UAgentCollisionComponent::StaticClass());
#else
		TArray<UActorComponent*> ExistingRagdollComponents;
		Actor->GetComponents(UAgentCollisionComponent::StaticClass(), ExistingRagdollComponents);
#endif
		for (auto It : ExistingRagdollComponents)
		{
			auto RagdollComp = Cast<UAgentCollisionComponent>(It);
			if (RagdollComp)
			{
				CollisionComponent = RagdollComp;
				break;
			}
		}

		// if there is no data just exit
		if (m_replicatorComponent->ClientReplicatedData.Num() == 0)
			return;

		float CurrentSimTime = agentGroup->simulationTime().time();
		
		auto* Tail = m_replicatorComponent->ClientReplicatedData.GetTail();
		auto& LastData = Tail->GetValue();
		
		while (Tail->GetPrevNode())
		{
			auto* NextNode = Tail->GetPrevNode();
			if (!NextNode)
				break;

			auto CurrTime = Tail->GetValue().SimulationTime;
			auto NextTime = NextNode->GetValue().SimulationTime;
			if (CurrentSimTime > NextTime)
			{
				m_replicatorComponent->ClientReplicatedData.RemoveNode(Tail);
			}

			Tail = NextNode;
		}

		Tail = m_replicatorComponent->ClientReplicatedData.GetTail();
		auto* Head = Tail->GetPrevNode();
		if (!Tail)
			return;
		

		float TimeTail = Tail->GetValue().SimulationTime;
		float TimeHead = Head ? Head->GetValue().SimulationTime : CurrentSimTime;

		float Alpha = (TimeHead > TimeTail) ? (CurrentSimTime - TimeTail) / (TimeHead - TimeTail) : 0.0;

		auto& TailState = Tail->GetValue();
		auto& ids = TailState.Ids;
		if (ids.Num() == 0)
			return;

		size_t DataStride = GetDataOffset(TailState.TypeId);

		size_t dataCounter = 0;
		for (size_t i = 0; i < ids.Num(); ++i)
		{
			auto agentId = ids[i];
			auto* agent = agentGroup->agent(agentId);
			if (!agent)
			{
				dataCounter += DataStride;
				continue;
			}

			auto CurrentData = agent->metadata().getEntry(metadataName->get());
			if (!CurrentData)
			{
				dataCounter += DataStride;
				continue;
			}

			// the metadata type id doesn't metch so continue;
			if (CurrentData->typeId() != TailState.TypeId)
			{
				dataCounter += DataStride;
				continue;
			}

			int32 HeadOffset = INDEX_NONE;
			FMetadataReplicatorState* HeadState = nullptr;
			if (interpolation && Head)
			{
				HeadState = &Head->GetValue();
				HeadOffset = HeadState->Ids.Find(agentId);
				if (HeadOffset == INDEX_NONE)
				{
					continue;
				}

				HeadOffset *= DataStride;
			}

			if (TailState.ValueMetadata.Num() < (dataCounter + DataStride))
			{
				break;
			}

			switch (TailState.TypeId)
			{
			case kMetadataBoolTypeId:
			{
				auto agentData = std::static_pointer_cast<AtomsCore::BoolMetadata>(CurrentData);
				agentData->set(TailState.ValueMetadata[dataCounter++] > 0.1);
				break;
			}
			case kMetadataStringTypeId:
			{
				auto agentData = std::static_pointer_cast<AtomsCore::StringMetadata>(CurrentData);
				agentData->get() = TCHAR_TO_UTF8(*TailState.StringMetadata[dataCounter++]);
				break;
			}
			case kMetadataIntTypeId:
			{
				auto agentData = std::static_pointer_cast<AtomsCore::IntMetadata>(CurrentData);
				if (!HeadState)
				{
					agentData->get() = TailState.ValueMetadata[dataCounter++];
				}
				else
				{
					agentData->get() = TailState.ValueMetadata[dataCounter] + Alpha * (HeadState->ValueMetadata[HeadOffset] - TailState.ValueMetadata[dataCounter]);
					dataCounter += 1;
				}

				break;
			}
			case kMetadataDoubleTypeId:
			{
				auto agentData = std::static_pointer_cast<AtomsCore::DoubleMetadata>(CurrentData);
				if (!HeadState)
				{
					agentData->get() = TailState.ValueMetadata[dataCounter++];
				}
				else
				{
					agentData->get() = TailState.ValueMetadata[dataCounter] + Alpha * (HeadState->ValueMetadata[HeadOffset] - TailState.ValueMetadata[dataCounter]);
					dataCounter += 1;
				}
				break;
			}
			case kMetadataFloatTypeId:
			{
				auto agentData = std::static_pointer_cast<AtomsCore::FloatMetadata>(CurrentData);
				if (!HeadState)
				{
					agentData->get() = TailState.ValueMetadata[dataCounter++];
				}
				else 
				{
					agentData->get() = TailState.ValueMetadata[dataCounter] + Alpha * (HeadState->ValueMetadata[HeadOffset] - TailState.ValueMetadata[dataCounter]);
					dataCounter += 1;
				}
				break;
			}
			case kMetadataVector3fTypeId:
			{
				auto agentData = std::static_pointer_cast<AtomsCore::Vector3fMetadata>(CurrentData);
				if (!HeadState)
				{
					agentData->get().x = TailState.ValueMetadata[dataCounter++];
					agentData->get().y = TailState.ValueMetadata[dataCounter++];
					agentData->get().z = TailState.ValueMetadata[dataCounter++];
				}
				else
				{
					agentData->get().x = TailState.ValueMetadata[dataCounter] + Alpha * (HeadState->ValueMetadata[HeadOffset] - TailState.ValueMetadata[dataCounter]);
					agentData->get().y = TailState.ValueMetadata[dataCounter + 1] + Alpha * (HeadState->ValueMetadata[HeadOffset + 1] - TailState.ValueMetadata[dataCounter + 1]);
					agentData->get().z = TailState.ValueMetadata[dataCounter + 2] + Alpha * (HeadState->ValueMetadata[HeadOffset + 2] - TailState.ValueMetadata[dataCounter + 2]);
					dataCounter += 3;
				}

				if (CollisionComponent && metadataName->get() == Atoms::GlobalNameKeys::ATOMS_AGENT_POSITION_KEY)
				{
					auto InstanceBody = CollisionComponent->InstanceBodies.Find(agentId);
					if (InstanceBody && *InstanceBody)
					{
						auto CurrentTransform = (*InstanceBody)->GetUnrealWorldTransform();
						CurrentTransform.SetLocation(AtomsConverter::FromVector3(agentData->get()));
						(*InstanceBody)->SetBodyTransform(CurrentTransform, ETeleportType::TeleportPhysics, false);
					}
				}
				break;
			}
			case kMetadataVector3TypeId:
			{
				auto agentData = std::static_pointer_cast<AtomsCore::Vector3Metadata>(CurrentData);
				if (!HeadState)
				{
					agentData->get().x = TailState.ValueMetadata[dataCounter++];
					agentData->get().y = TailState.ValueMetadata[dataCounter++];
					agentData->get().z = TailState.ValueMetadata[dataCounter++];
				}
				else
				{
					agentData->get().x = TailState.ValueMetadata[dataCounter] + Alpha * (HeadState->ValueMetadata[HeadOffset] - TailState.ValueMetadata[dataCounter]);
					agentData->get().y = TailState.ValueMetadata[dataCounter + 1] + Alpha * (HeadState->ValueMetadata[HeadOffset + 1] - TailState.ValueMetadata[dataCounter + 1]);
					agentData->get().z = TailState.ValueMetadata[dataCounter + 2] + Alpha * (HeadState->ValueMetadata[HeadOffset + 2] - TailState.ValueMetadata[dataCounter + 2]);
					dataCounter += 3;
				}

				if (CollisionComponent && metadataName->get() == Atoms::GlobalNameKeys::ATOMS_AGENT_POSITION_KEY)
				{
					auto InstanceBody = CollisionComponent->InstanceBodies.Find(agentId);
					if (InstanceBody && *InstanceBody)
					{
						auto CurrentTransform = (*InstanceBody)->GetUnrealWorldTransform();
						CurrentTransform.SetLocation(AtomsConverter::FromVector3(agentData->get()));
						(*InstanceBody)->SetBodyTransform(CurrentTransform, ETeleportType::TeleportPhysics, false);
					}
				}
				break;
			}
			case kMetadataEulerfTypeId:
			{
				auto agentData = std::static_pointer_cast<AtomsCore::EulerfMetadata>(CurrentData);
				if (!HeadState)
				{
					agentData->get().x = TailState.ValueMetadata[dataCounter++];
					agentData->get().y = TailState.ValueMetadata[dataCounter++];
					agentData->get().z = TailState.ValueMetadata[dataCounter++];
				}
				else
				{
					agentData->get().x = TailState.ValueMetadata[dataCounter] + Alpha * (HeadState->ValueMetadata[HeadOffset] - TailState.ValueMetadata[dataCounter]);
					agentData->get().y = TailState.ValueMetadata[dataCounter + 1] + Alpha * (HeadState->ValueMetadata[HeadOffset + 1] - TailState.ValueMetadata[dataCounter + 1]);
					agentData->get().z = TailState.ValueMetadata[dataCounter + 2] + Alpha * (HeadState->ValueMetadata[HeadOffset + 2] - TailState.ValueMetadata[dataCounter + 2]);
					dataCounter += 3;
				}
				break;
			}
			case kMetadataEulerTypeId:
			{
				auto agentData = std::static_pointer_cast<AtomsCore::EulerMetadata>(CurrentData);
				if (!HeadState)
				{
					agentData->get().x = TailState.ValueMetadata[dataCounter++];
					agentData->get().y = TailState.ValueMetadata[dataCounter++];
					agentData->get().z = TailState.ValueMetadata[dataCounter++];
				}
				else
				{
					agentData->get().x = TailState.ValueMetadata[dataCounter] + Alpha * (HeadState->ValueMetadata[HeadOffset] - TailState.ValueMetadata[dataCounter]);
					agentData->get().y = TailState.ValueMetadata[dataCounter + 1] + Alpha * (HeadState->ValueMetadata[HeadOffset + 1] - TailState.ValueMetadata[dataCounter + 1]);
					agentData->get().z = TailState.ValueMetadata[dataCounter + 2] + Alpha * (HeadState->ValueMetadata[HeadOffset + 2] - TailState.ValueMetadata[dataCounter + 2]);
					dataCounter += 3;
				}
				break;
			}
			case kMetadataVector4fTypeId:
			{
				auto agentData = std::static_pointer_cast<AtomsCore::Vector4fMetadata>(CurrentData);
				if (!HeadState)
				{
					agentData->get().x = TailState.ValueMetadata[dataCounter++];
					agentData->get().y = TailState.ValueMetadata[dataCounter++];
					agentData->get().z = TailState.ValueMetadata[dataCounter++];
					agentData->get().w = TailState.ValueMetadata[dataCounter++];
				}
				else
				{
					agentData->get().x = TailState.ValueMetadata[dataCounter] + Alpha * (HeadState->ValueMetadata[HeadOffset] - TailState.ValueMetadata[dataCounter]);
					agentData->get().y = TailState.ValueMetadata[dataCounter + 1] + Alpha * (HeadState->ValueMetadata[HeadOffset + 1] - TailState.ValueMetadata[dataCounter + 1]);
					agentData->get().z = TailState.ValueMetadata[dataCounter + 2] + Alpha * (HeadState->ValueMetadata[HeadOffset + 2] - TailState.ValueMetadata[dataCounter + 2]);
					agentData->get().w = TailState.ValueMetadata[dataCounter + 3] + Alpha * (HeadState->ValueMetadata[HeadOffset + 3] - TailState.ValueMetadata[dataCounter + 3]);
					dataCounter += 4;
				}
				break;
			}
			case kMetadataVector4TypeId:
			{
				auto agentData = std::static_pointer_cast<AtomsCore::Vector4Metadata>(CurrentData);
				if (!HeadState)
				{
					agentData->get().x = TailState.ValueMetadata[dataCounter++];
					agentData->get().y = TailState.ValueMetadata[dataCounter++];
					agentData->get().z = TailState.ValueMetadata[dataCounter++];
					agentData->get().w = TailState.ValueMetadata[dataCounter++];
				}
				else
				{
					agentData->get().x = TailState.ValueMetadata[dataCounter] + Alpha * (HeadState->ValueMetadata[HeadOffset] - TailState.ValueMetadata[dataCounter]);
					agentData->get().y = TailState.ValueMetadata[dataCounter + 1] + Alpha * (HeadState->ValueMetadata[HeadOffset + 1] - TailState.ValueMetadata[dataCounter + 1]);
					agentData->get().z = TailState.ValueMetadata[dataCounter + 2] + Alpha * (HeadState->ValueMetadata[HeadOffset + 2] - TailState.ValueMetadata[dataCounter + 2]);
					agentData->get().w = TailState.ValueMetadata[dataCounter + 3] + Alpha * (HeadState->ValueMetadata[HeadOffset + 3] - TailState.ValueMetadata[dataCounter + 3]);
					dataCounter += 4;
				}
				break;
			}
			case kMetadataQuaternionfTypeId:
			{
				auto agentData = std::static_pointer_cast<AtomsCore::QuaternionfMetadata>(CurrentData);
				if (!HeadState)
				{
					agentData->get().v.x = TailState.ValueMetadata[dataCounter++];
					agentData->get().v.y = TailState.ValueMetadata[dataCounter++];
					agentData->get().v.z = TailState.ValueMetadata[dataCounter++];
					agentData->get().r = TailState.ValueMetadata[dataCounter++];
				}
				else
				{
					agentData->get().v.x = TailState.ValueMetadata[dataCounter] + Alpha * (HeadState->ValueMetadata[HeadOffset] - TailState.ValueMetadata[dataCounter]);
					agentData->get().v.y = TailState.ValueMetadata[dataCounter + 1] + Alpha * (HeadState->ValueMetadata[HeadOffset + 1] - TailState.ValueMetadata[dataCounter + 1]);
					agentData->get().v.z = TailState.ValueMetadata[dataCounter + 2] + Alpha * (HeadState->ValueMetadata[HeadOffset + 2] - TailState.ValueMetadata[dataCounter + 2]);
					agentData->get().r = TailState.ValueMetadata[dataCounter + 3] + Alpha * (HeadState->ValueMetadata[HeadOffset + 3] - TailState.ValueMetadata[dataCounter + 3]);
					dataCounter += 4;
				}
				break;
			}
			case kMetadataQuaternionTypeId:
			{
				auto agentData = std::static_pointer_cast<AtomsCore::QuaternionMetadata>(CurrentData);
				if (!HeadState)
				{
					agentData->get().v.x = TailState.ValueMetadata[dataCounter++];
					agentData->get().v.y = TailState.ValueMetadata[dataCounter++];
					agentData->get().v.z = TailState.ValueMetadata[dataCounter++];
					agentData->get().r = TailState.ValueMetadata[dataCounter++];
				}
				else
				{
					agentData->get().v.x = TailState.ValueMetadata[dataCounter] + Alpha * (HeadState->ValueMetadata[HeadOffset] - TailState.ValueMetadata[dataCounter]);
					agentData->get().v.y = TailState.ValueMetadata[dataCounter + 1] + Alpha * (HeadState->ValueMetadata[HeadOffset + 1] - TailState.ValueMetadata[dataCounter + 1]);
					agentData->get().v.z = TailState.ValueMetadata[dataCounter + 2] + Alpha * (HeadState->ValueMetadata[HeadOffset + 2] - TailState.ValueMetadata[dataCounter + 2]);
					agentData->get().r = TailState.ValueMetadata[dataCounter + 3] + Alpha * (HeadState->ValueMetadata[HeadOffset + 3] - TailState.ValueMetadata[dataCounter + 3]);
					dataCounter += 4;
				}
				break;
			}
			case kMetadataMatrixfTypeId:
			{
				auto agentData = std::static_pointer_cast<AtomsCore::MatrixfMetadata>(CurrentData);
				if (!HeadState)
				{
					for (int32 xi = 0; xi < 4; ++xi)
						for (int32 yi = 0; yi < 4; ++yi)
							agentData->get()[xi][yi] = TailState.ValueMetadata[dataCounter++];
				}
				else
				{
					for (int32 xi = 0; xi < 4; ++xi)
						for (int32 yi = 0; yi < 4; ++yi)
							agentData->get()[xi][yi] = TailState.ValueMetadata[dataCounter + xi * 4 + yi] + Alpha * (HeadState->ValueMetadata[HeadOffset + xi * 4 + yi] - TailState.ValueMetadata[dataCounter + xi * 4 + yi]);
					dataCounter += 15;
				}
				break;
			}
			default:
				break;
			}
		}

		if (!serverStarted)
		{

			auto* UniqueHead = m_replicatorComponent->ClientReplicatedData.GetHead();
			if (UniqueHead)
			{
				float ServerTime = UniqueHead->GetValue().SimulationTime;
				auto AgentGroupActor = Cast<AAtomsAgentGroup>(Actor);
				if (AgentGroupActor)
					AgentGroupActor->CurrentFrame = ServerTime;
			}
			serverStarted = true;
		}
	}
	
}

Atoms::BehaviourModule* CustomMetadataReplicatorModule::creator(const std::string& parameter)
{
	return new MetadataReplicatorModule();
}

UCustomMetadataReplicatorComponent* CustomMetadataReplicatorModule::GetReplicatorComponent()
{
	return m_replicatorComponent;
}

Unreal Component

#pragma once

#include "CoreMinimal.h"
#include "Components/AtomsBehaviourComponent.h"
#include <Atoms/AgentGroup.h>
#include "CustomMetadataReplicatorComponent.generated.h"

USTRUCT()
struct FMetadataReplicatorState
{
	GENERATED_USTRUCT_BODY()

	UPROPERTY()
	int32 TypeId;

	UPROPERTY()
	float SimulationTime;

	UPROPERTY()
	TArray<int32> Ids;

	UPROPERTY()
	TArray<float> ValueMetadata;

	UPROPERTY()
	TArray<FString> StringMetadata;
};


UCLASS(ClassGroup = (AtomsBehaviours), meta = (DisplayName = "Metadata Replicator", BlueprintSpawnableComponent))
class ATOMSUNREAL_API UCustomMetadataReplicatorComponent : public UAtomsBehaviourComponent
{
	GENERATED_BODY()

public:

	UCustomMetadataReplicatorComponent();

	~UCustomMetadataReplicatorComponent();

	virtual void OnBehaviourModuleCreated(AtomsPtr<Atoms::BehaviourModule>& module) override;

	virtual void OnRegister() override;

	virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;

	virtual void GetAtomsAttributes(AtomsPtr<AtomsCore::MapMetadata>& attributes) override;

public:
	/* Enable the replication of the metadata, This can be override per agent using the enableReplicationOverride property or setting on the agent a bool metadata using as name thiscomponentname + "@enableReplication" */
	UPROPERTY(BlueprintReadWrite, EditAnywhere, Interp, Category = "Behaviour")
	bool EnableReplication;

	/* Enable the tick of the tree */
	UPROPERTY(BlueprintReadWrite, EditAnywhere, Interp, Category = "Behaviour")
	TMap<int32, bool> EnableReplicationOverride;

	/* Metadata name to replicate */
	UPROPERTY(replicated, EditAnywhere, Category = "Behaviour")
	FString MetadataName;

	/* Use interpolation. The component on the client store a list of value sent by the server at different simulation time.
	Interpolate the value between different times.*/
	UPROPERTY(replicated, EditAnywhere, Category = "Behaviour")
	bool Interpolate;

	/* Enable Rpc call to UpdatedMetadata instead use the ReplicatedMetadata property replication. 
	 Please use this only if you need really fast updates and if you have enough bandwidth.*/
	UPROPERTY(EditAnywhere, Category = "Behaviour")
	bool UseRpc;

	/* Use reliable rpc call */
	UPROPERTY(EditAnywhere, Category = "Behaviour", meta = (EditCondition = UseRpc))
	bool UseReliableRpc;

	/* Send the rpc call every UpdateTime in seconds */
	UPROPERTY(EditAnywhere, Category = "Behaviour", meta=(EditCondition = UseRpc))
	float UpdateTime;

	UPROPERTY(ReplicatedUsing = OnRep_ReplicatedMetadata)
	FMetadataReplicatorState ReplicatedMetadata;

	TDoubleLinkedList<FMetadataReplicatorState> ClientReplicatedData;

	UFUNCTION()
	void OnRep_ReplicatedMetadata();


	UFUNCTION(NetMulticast, Reliable)
	void UpdatedMetadata(const FMetadataReplicatorState& Data);

	UFUNCTION(NetMulticast, Unreliable)
	void UnreliableUpdatedMetadata(const FMetadataReplicatorState& Data);

	UFUNCTION(BlueprintCallable, Category = "MetadatareplicatorBehaviourComponent", meta = (CallInEditor = "true"))
	void SetEnableReplication(const bool Value, const int32 AgentId = -1);

	/** Remove agent override */
	UFUNCTION(BlueprintCallable, Category = "MetadatareplicatorBehaviourComponent", meta = (CallInEditor = "true"))
	void RemoveEnableReplicationOverride(const int32 AgentId);

	/** Set the metadata name to replicate */
	UFUNCTION(BlueprintCallable, Category = "MetadatareplicatorBehaviourComponent", meta = (CallInEditor = "true"))
	void SetMetadataName(const FString& Value, const int32 AgentId = -1);
};

#include "CustomMetadataReplicatorComponent.h"
#include "Net/UnrealNetwork.h"
#include "Actors/AtomsAgentGroup.h"
#include "Behaviours/MetadataReplicatorModule.h"
#include <AtomsUtils/Memory.h>
#include <AtomsCore/Metadata/Vector3fArrayMetadata.h>
#include <AtomsCore/Metadata/StringArrayMetadata.h>
#include <AtomsCore/Metadata/BoolArrayMetadata.h>
#include "AtomsModuleGeneratorUtils.h"
#include "AtomsAttributeUtils.h"
#include "GameFramework/GameStateBase.h"
#include "Engine/Player.h"

UCustomMetadataReplicatorComponent::UCustomMetadataReplicatorComponent()
{
	AtomsBehaviourModule = "custommetadatareplicator";
#if ENGINE_MINOR_VERSION < 25
	bReplicates = true;
#endif
	UpdateTime = 0.1;
	UseReliableRpc = true;
	EnableReplication = true;
}

UCustomMetadataReplicatorComponent::~UCustomMetadataReplicatorComponent()
{

}

void UCustomMetadataReplicatorComponent::OnRegister()
{
	Super::OnRegister();
#if ENGINE_MINOR_VERSION > 24
	SetIsReplicated(true);
#endif

}

void UCustomMetadataReplicatorComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{

}

void UCustomMetadataReplicatorComponent::GetLifetimeReplicatedProps(TArray< FLifetimeProperty > & OutLifetimeProps) const
{
	Super::GetLifetimeReplicatedProps(OutLifetimeProps);
	DOREPLIFETIME(UCustomMetadataReplicatorComponent, ReplicatedMetadata);
	DOREPLIFETIME(UCustomMetadataReplicatorComponent, MetadataName);
	DOREPLIFETIME(UCustomMetadataReplicatorComponent, Interpolate);
}

void  UCustomMetadataReplicatorComponent::OnBehaviourModuleCreated(AtomsPtr<Atoms::BehaviourModule>& module)
{
	Super::OnBehaviourModuleCreated(module);
	if (module->typeName() != "custommetadatareplicator")
		return;

	auto replicator = std::static_pointer_cast<MetadataReplicatorModule>(module);
	if (!replicator)
		return;

	replicator->setMetadataReplicatorComponent(this);
	if (GetOwner())
		replicator->setWorld(GetOwner()->GetWorld());

	AtomsCore::StringMetadata metaNames(TCHAR_TO_UTF8(*MetadataName));
	AtomsCore::BoolMetadata metadataInterpolation(Interpolate);
	replicator->attributes().addEntry("MetadataName", &metaNames);
	replicator->attributes().addEntry("MetadataInterpolation", &metadataInterpolation);
}

void UCustomMetadataReplicatorComponent::OnRep_ReplicatedMetadata()
{
	ClientReplicatedData.AddHead(ReplicatedMetadata);
}

void UCustomMetadataReplicatorComponent::UpdatedMetadata_Implementation(const FMetadataReplicatorState& Data)
{
	if (GetOwnerRole() == ROLE_Authority)
		return;

	ClientReplicatedData.AddHead(Data);
}

void UCustomMetadataReplicatorComponent::UnreliableUpdatedMetadata_Implementation(const FMetadataReplicatorState& Data)
{
	if (GetOwnerRole() == ROLE_Authority)
		return;

	ClientReplicatedData.AddHead(Data);
}

void UCustomMetadataReplicatorComponent::SetEnableReplication(const bool Value, const int32 AgentId)
{
	if (AgentId < 0)
	{
		EnableReplication = Value;
		ATOMS_BEHAVIOUR_COMPONENT_GET_ATTRIBUTES()
		ATOMS_BEHAVIOUR_COMPONENT_CONVERT_META(EnableReplication, AtomsCore::BoolMetadata, );
	}
	else
	{
		ATOMS_BEHAVIOUR_COMPONENT_SET_META_OVERRIDE(EnableReplication_override, EnableReplicationOverride, AtomsCore::BoolMetadata, , AgentId);

	}
}

void UCustomMetadataReplicatorComponent::RemoveEnableReplicationOverride(const int32 AgentId)
{
	ATOMS_BEHAVIOUR_COMPONENT_REMOVE_OVERRIDE(EnableReplication_override, EnableReplicationOverride, AgentId);
}

void UCustomMetadataReplicatorComponent::SetMetadataName(const FString& Value, const int32 AgentId)
{
	if (AgentId < 0)
	{
		MetadataName = Value;
		ATOMS_BEHAVIOUR_COMPONENT_GET_ATTRIBUTES()
		ATOMS_BEHAVIOUR_COMPONENT_CONVERT_META(MetadataName, AtomsCore::StringMetadata, UAtomsAttributeUtils::ToString);
	}
}

void UCustomMetadataReplicatorComponent::GetAtomsAttributes(AtomsPtr<AtomsCore::MapMetadata>& attributes)
{
	ATOMS_BEHAVIOUR_COMPONENT_CONVERT_META(EnableReplication, AtomsCore::BoolMetadata, );
	ATOMS_BEHAVIOUR_COMPONENT_CONVERT_META_OVERRIDE(EnableReplication_override, EnableReplicationOverride, AtomsCore::BoolMetadata, );
	ATOMS_BEHAVIOUR_COMPONENT_CONVERT_META(MetadataName, AtomsCore::StringMetadata, UAtomsAttributeUtils::ToString);
}

Atoms module registration

#include "CustomMetadataReplicatorModule.h"
#include <Atoms/BehaviourModules.h>

void FAtomsTestModule::StartupModule()
{
	Atoms::BehaviourModules& moduleManager = Atoms::BehaviourModules::instance();
	moduleManager.registerBehaviourModule("custommetadatareplicator", &CustomMetadataReplicatorModule::creator, Atoms::BehaviourModules::kNative, true, "Unreal");
}

void FAtomsTestModule::StartupModule()
{
	Atoms::BehaviourModules& moduleManager = Atoms::BehaviourModules::instance();
	moduleManager.deregisterBehaviourModule("custommetadatareplicator");
}

Atoms Crowd Documentation

Writing a Metadata Replicator module

Related content