El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

En este módulo, aprenderás a implementar funcionalidades de red y multijugador en Unreal Engine utilizando C++. Este es un tema avanzado que requiere una comprensión sólida de la programación en C++ y de los conceptos básicos de Unreal Engine. A lo largo de esta sección, cubriremos los siguientes temas:

Conceptos Básicos de Redes en Unreal Engine
Configuración de un Proyecto Multijugador
Replicación de Actores
Sincronización de Variables y Funciones
Manejo de Conexiones y Sesiones

Conceptos Básicos de Redes en Unreal Engine

¿Qué es la Replicación?

La replicación es el proceso mediante el cual el servidor y los clientes mantienen sincronizados los datos del juego. En Unreal Engine, los actores pueden ser replicados para que sus estados se mantengan consistentes en todas las instancias del juego.

Modelos de Red

Unreal Engine utiliza un modelo de red cliente-servidor, donde el servidor es la autoridad y los clientes se conectan a él para recibir actualizaciones del estado del juego.

Configuración de un Proyecto Multijugador

Paso 1: Crear un Proyecto Nuevo

Abre Unreal Engine y selecciona "New Project".
Elige la plantilla "Third Person" o cualquier otra que prefieras.
Asegúrate de habilitar la opción "With Starter Content".
Haz clic en "Create Project".

Paso 2: Configurar las Opciones de Red

Abre el archivo DefaultEngine.ini en la carpeta Config de tu proyecto.
Añade las siguientes líneas para habilitar la replicación:

[/Script/Engine.GameNetworkManager]
TotalNetBandwidth=500000
MaxDynamicBandwidth=8000
MinDynamicBandwidth=4000

Paso 3: Configurar el Modo de Juego

Abre el archivo MyGameMode.cpp y asegúrate de que el modo de juego esté configurado para soportar multijugador:

AMyGameMode::AMyGameMode()
{
    // Habilitar el uso de un servidor dedicado
    bUseSeamlessTravel = true;
}

Replicación de Actores

Paso 1: Crear un Actor Replicable

Crea una nueva clase de C++ que herede de AActor.
En el archivo de cabecera (MyActor.h), añade las siguientes líneas:

UCLASS()
class MYPROJECT_API AMyActor : public AActor
{
    GENERATED_BODY()

public:
    AMyActor();

protected:
    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;

    UPROPERTY(Replicated)
    int32 MyReplicatedVariable;
};

En el archivo de implementación (MyActor.cpp), añade las siguientes líneas:

AMyActor::AMyActor()
{
    bReplicates = true;
}

void AMyActor::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);

    DOREPLIFETIME(AMyActor, MyReplicatedVariable);
}

Paso 2: Probar la Replicación

Coloca una instancia de AMyActor en tu nivel.
Ejecuta el juego en modo multijugador (Editor > Play > Advanced Settings > Number of Players).

Sincronización de Variables y Funciones

Replicación de Variables

Para replicar una variable, usa la macro UPROPERTY con el parámetro Replicated:

UPROPERTY(Replicated)
int32 MyReplicatedVariable;

Replicación de Funciones

Para replicar una función, usa la macro UFUNCTION con el parámetro Server o Client:

UFUNCTION(Server, Reliable, WithValidation)
void ServerFunction();

UFUNCTION(Client, Reliable)
void ClientFunction();

Implementación de Funciones Replicadas

En el archivo de implementación (MyActor.cpp):

void AMyActor::ServerFunction_Implementation()
{
    // Lógica del servidor
}

bool AMyActor::ServerFunction_Validate()
{
    return true; // Validación de la función
}

void AMyActor::ClientFunction_Implementation()
{
    // Lógica del cliente
}

Manejo de Conexiones y Sesiones

Crear una Sesión

En el archivo de cabecera (MyGameInstance.h), añade las siguientes líneas:

UCLASS()
class MYPROJECT_API UMyGameInstance : public UGameInstance
{
    GENERATED_BODY()

public:
    UFUNCTION(BlueprintCallable)
    void CreateGameSession();
};

En el archivo de implementación (MyGameInstance.cpp), añade las siguientes líneas:

void UMyGameInstance::CreateGameSession()
{
    IOnlineSubsystem* OnlineSubsystem = IOnlineSubsystem::Get();
    if (OnlineSubsystem)
    {
        IOnlineSessionPtr Sessions = OnlineSubsystem->GetSessionInterface();
        if (Sessions.IsValid())
        {
            FOnlineSessionSettings SessionSettings;
            SessionSettings.bIsLANMatch = true;
            SessionSettings.NumPublicConnections = 4;
            SessionSettings.bShouldAdvertise = true;

            Sessions->CreateSession(0, TEXT("GameSession"), SessionSettings);
        }
    }
}

Unirse a una Sesión

En el archivo de cabecera (MyGameInstance.h), añade las siguientes líneas:

UFUNCTION(BlueprintCallable)
void JoinGameSession();

En el archivo de implementación (MyGameInstance.cpp), añade las siguientes líneas:

void UMyGameInstance::JoinGameSession()
{
    IOnlineSubsystem* OnlineSubsystem = IOnlineSubsystem::Get();
    if (OnlineSubsystem)
    {
        IOnlineSessionPtr Sessions = OnlineSubsystem->GetSessionInterface();
        if (Sessions.IsValid())
        {
            Sessions->FindSessions(0, SearchSettings.ToSharedRef());
        }
    }
}

Ejercicio Práctico

Ejercicio 1: Crear un Actor Replicable

Crea una nueva clase de C++ llamada MyReplicatedActor que herede de AActor.
Añade una variable replicada llamada Health de tipo int32.
Implementa la replicación de la variable Health.
Coloca una instancia de MyReplicatedActor en tu nivel y prueba la replicación en modo multijugador.

Solución

Crear la clase MyReplicatedActor:

UCLASS()
class MYPROJECT_API AMyReplicatedActor : public AActor
{
    GENERATED_BODY()

public:
    AMyReplicatedActor();

protected:
    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;

    UPROPERTY(Replicated)
    int32 Health;
};

Implementar la replicación en MyReplicatedActor.cpp:

AMyReplicatedActor::AMyReplicatedActor()
{
    bReplicates = true;
    Health = 100;
}

void AMyReplicatedActor::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);

    DOREPLIFETIME(AMyReplicatedActor, Health);
}

Conclusión

En esta sección, hemos cubierto los conceptos básicos de redes y multijugador en Unreal Engine, incluyendo la configuración de un proyecto multijugador, la replicación de actores, la sincronización de variables y funciones, y el manejo de conexiones y sesiones. Estos conocimientos te permitirán crear experiencias multijugador robustas y eficientes en tus proyectos de Unreal Engine. En el próximo módulo, exploraremos técnicas avanzadas de optimización para mejorar el rendimiento de tus juegos multijugador.

Redes y Multijugador