Uso de GridMate para escalas grandes Mundos - Lumberyard Guía del usuario

Si proporcionásemos una traducción de la versión en inglés de la guía, prevalecerá la versión en inglés de la guía si hubiese algún conflicto. La traducción se proporciona mediante traducción automática.

Uso de GridMate para escalas grandes Mundos

El GridMate es Lumberyarddel sistema de red de. El gestor de intereses es Lumberyardde solución a gran escala mundos en red.

La relación entre el administrador de réplicas y el administrador de intereses

Interest Manager es una característica opcional que controla el envío de réplicas en Las aplicaciones de juegos de red a gran escala. Administrador de réplicas funciona sin gestor de intereses. Sin embargo, El administrador de réplicas de envía réplicas a todos los homólogos de. Por lo tanto, todas las entidades asociadas con la red El componente vinculante en ellos aparece en todos los pares. Cuando se crea el componente Interest Manager y inicializado, indica al administrador de réplicas que ya no retransmita todas las réplicas a todos los homólogos. El gestor de intereses actúa como supervisor del administrador de réplicas y coordina las réplicas y de sus compañeros.


        Gestor de réplicas y gestor de intereses

Interés Responsable

La difusión de todas las réplicas a todos los pares no es factible para los mundos en red a gran escala. Para estas aplicaciones, puede utilizar Interest Manager para controlar qué réplicas se difunden con qué compañeros y en qué condiciones. El siguiente diagrama muestra la relación entre de interés, clientes y réplicas.


        Gestor de intereses, clientes y réplicas

En esta disposición, las réplicas tienen atributos. Cada el compañero puede tener reglas que definen las condiciones bajo las cuales Los atributos de se asocian y se envían a o se eliminan de ese homólogo. Su servidor o autoridad el compañero puede tener varios Controladores de reglas de que coinciden con las reglas de los atributos. El gestor de intereses realiza el trabajo de emparejar y fusionar resultados y enviar o eliminar réplicas de los homólogos adecuados.

Supongamos que desea crear un sistema espacial que replique objetos en función de dónde su cliente de mismo nivel se encuentra en su mundo. Un atributo sería un volumen geométrico que representa la ubicación y los límites de la réplica. A regla definiría un volumen geométrico que su cliente en su proximidad de interés. La controlador de reglas sería realizar la correspondencia espacial inteligente entre estos objetos espaciales.

En un nivel bajo, GridMate utiliza las siguientes construcciones para implementar atributos, reglas y los controladores:

GridMate::ProximityInterestAttribute GridMate::ProximityInterestRule GridMate::ProximityInterestHandler

El Ejemplo de multijugador que se incluye con Lumberyard contiene un la implementación práctica de estos. Para obtener información detallada sobre cómo escribir sus propios atributos, y controladores de reglas, consulte Cómo escribir sus propios intereses Atributos, reglas y controladores de reglas del administrador en C++.

Almacenamiento en caché de sectores y entidad Administración del ciclo de vida

NetBindingSystem almacena en caché sectores para el administrador de intereses. Las instancias de sector son almacenado en caché y reutilizado para las entidades de la misma instancia de sector. Siempre que una réplica se , se busca en la caché para ver si un sector que contiene la entidad ya está en el en caché. Si la búsqueda se realiza correctamente, la entidad se reutiliza.

Cuando una entidad de juego ya no es necesaria (es decir, UnBindGameEntity se llama), NetBindingSystem decide si desactivar la entidad o destruirla. Si el la entidad está en la caché, NetBindingSystem desactiva la entidad. Si la entidad es no encontrado en la caché, NetBindingSystem destruye la entidad.

Implementación de muestra multijugador

El ejemplo multijugador muestra cómo lograr el filtrado basado en intereses de entidades en red en su propia aplicación.

Dado que el objetivo es controlar las entidades, el gestor de intereses debe trabajar con entidades y los componentes. El ejemplo multijugador utiliza los siguientes componentes para lograrlo:

  • Gestor de intereses

  • Interés neto del jugador del juego

  • Interés neto de proximidad

Aunque la muestra no es exhaustiva, proporciona un punto de partida para que usted comprenda la tecnología e implemente un sistema que se adapte a sus necesidades.

Componente de gestor de intereses

Lumberyardde AzFramework::InterestManagerComponent está diseñado para su uso como del sistema en su aplicación.

El InterestManagerComponent inicializa tanto el gestor de intereses como el siguientes controladores de reglas integrados:

  • Controlador de reglas de proximidad (GridMate::ProximityInterestHandler) – Utilice el controlador de reglas de proximidad para especificar, en función de su proximidad espacial, que Las entidades de aparecen en cada uno de sus homólogos. El controlador de reglas utiliza un límite alineado con el eje cajas.

  • Controlador de reglas de máscara de bits (GridMate::BitmaskInterestHandler) – Uso el controlador de reglas de máscara de bits para filtrar las réplicas en función del valor de máscara de bits. Esto es útil para entidades cuya presencia se determina mediante la agrupación personalizada.

Para registrarse InterestManagerComponent como componente del sistema, anular AZ:: Module:: GetRequiredSystemComponents(). Como componente del sistema, el InterestManagerComponent se inicializa antes que cualquier otra entidad que no sea del sistema y componentes que no sean del sistema. Para obtener más información, consulte Componentes del sistema.

Para obtener referencia, consulte el siguiente código. El archivo de origen es \dev\MultiplayerSample\Gem\Code\Source\MultiplayerSampleModule.cpp.

class MultiplayerSample : public CryHooksModule { public: MultiplayerSample() : CryHooksModule() { ... // System Components RegisterSystemComponent<AzFramework::InterestManagerComponent>(); // enabling interest management ... } template<class T> void RegisterSystemComponent() { m_descriptors.push_back(T::CreateDescriptor()); m_systemComponents.push_back(azrtti_typeid<T>()); } /** * Add required SystemComponents to the SystemEntity. */ AZ::ComponentTypeList GetRequiredSystemComponents() const { return m_systemComponents; // this is how Lumberyard will get your system components and attach them on your behalf } ... AZ::ComponentTypeList m_systemComponents; };

Juego Interés neto del jugador

La regla de interés neto del jugador (MultiplayerSample::GamePlayerNetInterest) define las entidades en las que el jugador de juego está interesado y contiene el GridMate::ProximityInterestRule. El variable de consola mps_interestRadius determina el radio de la de interés. El ejemplo de multijugador utiliza el siguiente procedimiento para crear la entidad de jugador. Puede encontrar el código fuente en el archivo dev\MultiplayerSample\Gem\Code\Source\Components\Spawn\PlayerSpawnComponent.cpp.

void PlayerSpawnComponent::SpawnPlayerEntity() { if (m_playerEntity == nullptr) { m_playerEntity = aznew AZ::Entity("Game Player"); if (m_playerEntity) { m_playerEntity->CreateComponent<GamePlayerComponent>(); m_playerEntity->CreateComponent<GamePlayerNetInterest>(); m_playerEntity->CreateComponent<AzFramework::NetBindingComponent>(); m_playerEntity->Init(); m_playerEntity->Activate(); AZ::EntityBus::MultiHandler::BusConnect(m_playerEntity->GetId()); } ... } }

La regla se crea en GamePlayerNetInterest::BindTargetEntity(), que es se llama cuando la réplica de esta entidad está vinculada a. La ubicación del código fuente es \dev\MultiplayerSample\Gem\Code\Source\Components\Networking\GamePlayerNetInterest.cpp.

void GamePlayerNetInterest::BindTargetEntity(const AZ::EntityId& entityId) { ... PeerId peerId = InvalidReplicaPeerId; EBUS_EVENT_ID_RESULT(peerId, GetEntityId(), GamePlayerInterfaceBus, GetPeerId); // Find our own peer ID. ProximityInterestHandler* proximityInterest = nullptr; EBUS_EVENT_RESULT(proximityInterest, AzFramework::InterestManagerRequestsBus, GetProximityInterest); if (proximityInterest) { m_proximityRule = proximityInterest->CreateRule(peerId); // Finally, create the interest manager rule. } ... }

Después de crear la regla, la información espacial se puede establecer en cualquier momento. El Usos de muestra multijugador OnTick para actualizar la ubicación del jugador. GamePlayerNetInterest recupera la última transformación de la ubicación del jugador y establece la regla de proximidad local en consecuencia. El código fuente está en GamePlayerNetInterest.cpp.

void GamePlayerNetInterest::OnTick(float deltaTime, AZ::ScriptTimePoint time) { ... AZ::Transform worldTM; EBUS_EVENT_ID_RESULT(worldTM, m_targetEntityId, AZ::TransformBus, GetWorldTM); // This updates your local proximity rules that define which entities you are interested in. m_proximityRule->Set(AZ::Aabb::CreateCenterRadius(worldTM.GetPosition(), m_interestRadius)); }

Componente de interés neto de proximidad

El componente Proximity Net Interest describe el atributo de la entidad a la que está adjunto. El componente escucha los cambios de transformación de la entidad y actualiza su del atributo interno según corresponda. Esto permite al gestor de intereses controlar la presencia de la entidad en homólogos en función del interés neto del jugador del juego de los homólogos. En la pestaña Entidad Inspector, el nombre de este componente es Interés de proximidad atributo.


        del atributo Proximity Interest en el campo Entity Inspector

Las entidades filtradas por el gestor de intereses tienen el componente Proximity Net Interest (Interés neto de proximidad) adjunto. Este componente escucha para transformar los cambios de TransformComponent y actualiza su atributo GridMate en consecuencia. El siguiente es el fragmento de código relacionado de \dev\MultiplayerSample\Gem\Code\Source\Components\Networking\ProximityNetInterest.cpp.

void ProximityNetInterestComponent::OnTransformChanged(const AZ::Transform& localTM, const AZ::Transform& worldTM) { ... AZ::Aabb bbox = AZ::Aabb::CreateNull(); CollisionInfo info; EBUS_EVENT_ID_RESULT(info, GetEntityId(), CollidableBus, GetCollisionInfo); // Get our bounding box. if (info.m_shape) { bbox = info.m_shape->GetEncompassingAabb(); } m_attribute->Set(bbox); // Update GridMate::ProximityInterestAttribute value for the interest manager. ... }