El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Comunicació entre Blueprints

Següent ►
►

En aquest tema, aprendrem com els diferents Blueprints poden comunicar-se entre ells dins d'Unreal Engine. La comunicació entre Blueprints és essencial per crear comportaments complexos i interactius en els teus projectes. Explorarem diverses tècniques per aconseguir aquesta comunicació, incloent-hi la utilització de variables, funcions, esdeveniments i referències.

Objectius d'Aprenentatge

  • Entendre la importància de la comunicació entre Blueprints.
  • Aprendre a utilitzar variables i funcions per comunicar-se entre Blueprints.
  • Utilitzar esdeveniments per enviar missatges entre Blueprints.
  • Crear referències per accedir a altres Blueprints.

  1. Comunicació Bàsica amb Variables

1.1. Variables Globals

Les variables globals són accessibles des de qualsevol Blueprint. Aquestes variables es poden definir en el GameInstance o en altres Blueprints globals.

Exemple:

// Creem una variable global en el GameInstance
UPROPERTY(BlueprintReadWrite, Category="Global Variables")
int32 GlobalScore;

1.2. Variables d'Instància

Les variables d'instància són específiques d'un objecte i només són accessibles des d'aquest objecte.

Exemple:

// Creem una variable d'instància en un Blueprint d'actor
UPROPERTY(BlueprintReadWrite, Category="Instance Variables")
int32 Health;

  1. Comunicació amb Funcions

2.1. Funcions Públiques

Les funcions públiques poden ser cridades des d'altres Blueprints.

Exemple:

// Definim una funció pública en un Blueprint d'actor
UFUNCTION(BlueprintCallable, Category="Communication")
void UpdateHealth(int32 NewHealth);

2.2. Cridant Funcions des d'Altres Blueprints

Per cridar una funció d'un altre Blueprint, necessitem una referència a aquest Blueprint.

Exemple:

// Obtenim una referència a un altre Blueprint i cridem la seva funció
AActor* TargetActor = GetWorld()->SpawnActor<AActor>(TargetActorClass);
if (TargetActor)
{
    TargetActor->UpdateHealth(100);
}

  1. Comunicació amb Esdeveniments

3.1. Esdeveniments Personalitzats

Els esdeveniments personalitzats permeten enviar missatges entre Blueprints de manera asíncrona.

Exemple:

// Definim un esdeveniment personalitzat en un Blueprint
UFUNCTION(BlueprintImplementableEvent, Category="Communication")
void OnHealthChanged(int32 NewHealth);

3.2. Cridant Esdeveniments des d'Altres Blueprints

Podem cridar esdeveniments personalitzats des d'altres Blueprints de manera similar a les funcions.

Exemple:

// Cridem un esdeveniment personalitzat en un altre Blueprint
AActor* TargetActor = GetWorld()->SpawnActor<AActor>(TargetActorClass);
if (TargetActor)
{
    TargetActor->OnHealthChanged(100);
}

  1. Creant Referències entre Blueprints

4.1. Referències Directes

Les referències directes permeten accedir a altres Blueprints directament.

Exemple:

// Creem una referència directa a un altre Blueprint
UPROPERTY(BlueprintReadWrite, Category="References")
AActor* TargetActor;

4.2. Obtenint Referències en Temps d'Execució

Podem obtenir referències a altres Blueprints en temps d'execució utilitzant funcions com GetAllActorsOfClass.

Exemple:

// Obtenim una referència a un altre Blueprint en temps d'execució
TArray<AActor*> FoundActors;
UGameplayStatics::GetAllActorsOfClass(GetWorld(), TargetActorClass, FoundActors);
if (FoundActors.Num() > 0)
{
    TargetActor = FoundActors[0];
}

Exercicis Pràctics

Exercici 1: Comunicació amb Variables

  1. Crea dos Blueprints d'actors: ActorA i ActorB.
  2. Defineix una variable Health en ActorA.
  3. Fes que ActorB pugui llegir i modificar la variable Health de ActorA.

Exercici 2: Comunicació amb Funcions

  1. Defineix una funció UpdateScore en ActorA que actualitzi una variable Score.
  2. Fes que ActorB cridi la funció UpdateScore de ActorA quan es produeixi un esdeveniment específic.

Exercici 3: Comunicació amb Esdeveniments

  1. Defineix un esdeveniment personalitzat OnScoreUpdated en ActorA.
  2. Fes que ActorB cridi l'esdeveniment OnScoreUpdated de ActorA quan es produeixi un esdeveniment específic.

Solucions

Solució Exercici 1

// ActorA.h
UPROPERTY(BlueprintReadWrite, Category="Health")
int32 Health;

// ActorB.cpp
AActor* ActorA = GetWorld()->SpawnActor<AActor>(ActorAClass);
if (ActorA)
{
    ActorA->Health = 100;
}

Solució Exercici 2

// ActorA.h
UFUNCTION(BlueprintCallable, Category="Score")
void UpdateScore(int32 NewScore);

// ActorB.cpp
AActor* ActorA = GetWorld()->SpawnActor<AActor>(ActorAClass);
if (ActorA)
{
    ActorA->UpdateScore(50);
}

Solució Exercici 3

// ActorA.h
UFUNCTION(BlueprintImplementableEvent, Category="Score")
void OnScoreUpdated(int32 NewScore);

// ActorB.cpp
AActor* ActorA = GetWorld()->SpawnActor<AActor>(ActorAClass);
if (ActorA)
{
    ActorA->OnScoreUpdated(50);
}

Conclusió

La comunicació entre Blueprints és una habilitat fonamental per desenvolupar projectes complexos a Unreal Engine. Hem explorat diverses tècniques per aconseguir aquesta comunicació, incloent-hi l'ús de variables, funcions, esdeveniments i referències. Practica aquestes tècniques per millorar la interactivitat i la complexitat dels teus projectes. En el proper tema, aprofundirem en la creació d'objectes interactius utilitzant Blueprints.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats