El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència

HOME

En aquest tema, explorarem com implementar funcionalitats de xarxa i multijugador en Unreal Engine utilitzant C++. Aprendrem els conceptes bàsics de la programació de xarxes, com configurar un projecte per a multijugador i com gestionar la comunicació entre clients i servidors.

Conceptes Bàsics de Xarxes

Abans de començar a programar, és important entendre alguns conceptes bàsics de xarxes:

Client-Servidor: En un joc multijugador, el servidor és responsable de gestionar la lògica del joc i sincronitzar els estats entre els diferents clients (jugadors).
Replicació: La replicació és el procés de sincronitzar dades entre el servidor i els clients.
RPC (Remote Procedure Call): Les RPC permeten que els clients i el servidor cridin funcions remotes entre si.

Configurant el Projecte per a Multijugador

Pas 1: Habilitar el Suport de Xarxes

Obre el teu projecte a Unreal Engine.
Ves a Edit > Project Settings.
A la secció Engine > Network, assegura't que Enable Multiplayer estigui activat.

Pas 2: Configurar el Mode de Joc

Crea una nova classe de C++ derivada de AGameModeBase.
Configura el mode de joc per utilitzar la nova classe.

// MyGameMode.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/GameModeBase.h"
#include "MyGameMode.generated.h"

UCLASS()
class MYPROJECT_API AMyGameMode : public AGameModeBase
{
    GENERATED_BODY()

public:
    AMyGameMode();
};

// MyGameMode.cpp
#include "MyGameMode.h"

AMyGameMode::AMyGameMode()
{
    // Configura el mode de joc per a multijugador
    bUseSeamlessTravel = true;
}

Implementant la Replicació

Pas 1: Crear una Classe de Jugador

Crea una nova classe de C++ derivada de ACharacter.

// MyCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyCharacter.generated.h"

UCLASS()
class MYPROJECT_API AMyCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyCharacter();

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

public:
    UPROPERTY(Replicated, VisibleAnywhere, BlueprintReadOnly, Category = "Health")
    float Health;
};

// MyCharacter.cpp
#include "MyCharacter.h"
#include "Net/UnrealNetwork.h"

AMyCharacter::AMyCharacter()
{
    // Habilitar la replicació
    bReplicates = true;
    Health = 100.0f;
}

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

    // Replicar la propietat de salut
    DOREPLIFETIME(AMyCharacter, Health);
}

Pas 2: Implementar RPCs

Afegir una funció RPC per danyar el jugador.

// MyCharacter.h
UFUNCTION(Server, Reliable, WithValidation)
void ServerTakeDamage(float Damage);

void ServerTakeDamage_Implementation(float Damage);
bool ServerTakeDamage_Validate(float Damage);

// MyCharacter.cpp
void AMyCharacter::ServerTakeDamage_Implementation(float Damage)
{
    Health -= Damage;
}

bool AMyCharacter::ServerTakeDamage_Validate(float Damage)
{
    // Validar el dany (per exemple, assegurar-se que no és negatiu)
    return Damage > 0;
}

Exercici Pràctic

Exercici 1: Crear un Sistema de Danys Multijugador

Crea una nova classe de C++ derivada de AActor anomenada AWeapon.
Implementa una funció que danyi els jugadors quan són colpejats per l'arma.
Assegura't que la funció utilitzi RPCs per replicar el dany als clients.

Solució

// Weapon.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Weapon.generated.h"

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

public:
    AWeapon();

protected:
    virtual void BeginPlay() override;

public:
    UFUNCTION(Server, Reliable, WithValidation)
    void ServerDealDamage(AActor* HitActor, float Damage);

    void ServerDealDamage_Implementation(AActor* HitActor, float Damage);
    bool ServerDealDamage_Validate(AActor* HitActor, float Damage);
};

// Weapon.cpp
#include "Weapon.h"
#include "MyCharacter.h"
#include "Net/UnrealNetwork.h"

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

void AWeapon::BeginPlay()
{
    Super::BeginPlay();
}

void AWeapon::ServerDealDamage_Implementation(AActor* HitActor, float Damage)
{
    if (AMyCharacter* HitCharacter = Cast<AMyCharacter>(HitActor))
    {
        HitCharacter->ServerTakeDamage(Damage);
    }
}

bool AWeapon::ServerDealDamage_Validate(AActor* HitActor, float Damage)
{
    return Damage > 0;
}

Resum

En aquesta secció, hem après els conceptes bàsics de la programació de xarxes en Unreal Engine, com configurar un projecte per a multijugador, i com implementar la replicació i les RPCs. També hem creat un sistema de danys multijugador com a exercici pràctic. Amb aquests coneixements, estàs preparat per començar a desenvolupar jocs multijugador complexos en Unreal Engine.

Xarxes i Multijugador

Conceptes Bàsics de Xarxes

Configurant el Projecte per a Multijugador

Pas 1: Habilitar el Suport de Xarxes

Pas 2: Configurar el Mode de Joc

Implementant la Replicació

Pas 1: Crear una Classe de Jugador

Pas 2: Implementar RPCs

Exercici Pràctic

Exercici 1: Crear un Sistema de Danys Multijugador

Solució

Resum

Curs d'Unreal Engine

Mòdul 1: Introducció a Unreal Engine

Mòdul 2: Conceptes Bàsics

Mòdul 3: Blueprints Intermedis

Mòdul 4: Blueprints Avançats

Mòdul 5: Programació en C++ a Unreal Engine

Mòdul 6: Programació Avançada en C++

Mòdul 7: Temes Avançats

Mòdul 8: Desenvolupament de Projectes