El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Creando Clases en C++

Siguiente ►
►

En este tema, aprenderás cómo crear y utilizar clases en C++ dentro de Unreal Engine. Las clases son fundamentales en la programación orientada a objetos y te permitirán estructurar tu código de manera eficiente y modular.

Objetivos del Tema

  • Entender la estructura básica de una clase en C++.
  • Aprender a crear clases en Unreal Engine.
  • Conocer cómo declarar y definir métodos y propiedades.
  • Integrar clases C++ con Blueprints.

Estructura Básica de una Clase en C++

Una clase en C++ se compone de una declaración y una definición. La declaración se realiza en un archivo de cabecera (.h) y la definición en un archivo de implementación (.cpp).

Declaración de una Clase

// MyClass.h
#pragma once

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

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

public:
    // Constructor
    AMyClass();

protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public:
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    // Example property
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Example")
    int32 ExampleProperty;

    // Example method
    UFUNCTION(BlueprintCallable, Category = "Example")
    void ExampleMethod();
};

Definición de una Clase

// MyClass.cpp
#include "MyClass.h"

// Constructor
AMyClass::AMyClass()
{
    // Set this actor to call Tick() every frame.
    PrimaryActorTick.bCanEverTick = true;
}

// Called when the game starts or when spawned
void AMyClass::BeginPlay()
{
    Super::BeginPlay();
}

// Called every frame
void AMyClass::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
}

// Example method definition
void AMyClass::ExampleMethod()
{
    // Method logic here
}

Creando Clases en Unreal Engine

Paso 1: Crear una Nueva Clase

  1. Abre tu proyecto en Unreal Engine.
  2. Ve a la pestaña "File" y selecciona "New C++ Class".
  3. Elige la clase base adecuada (por ejemplo, Actor).
  4. Asigna un nombre a tu clase (por ejemplo, MyClass).
  5. Haz clic en "Create Class".

Paso 2: Modificar la Clase

Una vez creada la clase, Unreal Engine generará automáticamente los archivos de cabecera (.h) y de implementación (.cpp). Puedes modificar estos archivos para agregar propiedades y métodos según tus necesidades.

Ejemplo Práctico

Vamos a crear una clase AMyActor que tenga una propiedad Health y un método TakeDamage.

Declaración de la Clase

// MyActor.h
#pragma once

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

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

public:
    // Constructor
    AMyActor();

protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public:
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    // Health property
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
    float Health;

    // TakeDamage method
    UFUNCTION(BlueprintCallable, Category = "Stats")
    void TakeDamage(float DamageAmount);
};

Definición de la Clase

// MyActor.cpp
#include "MyActor.h"

// Constructor
AMyActor::AMyActor()
{
    // Set this actor to call Tick() every frame.
    PrimaryActorTick.bCanEverTick = true;

    // Initialize Health
    Health = 100.0f;
}

// Called when the game starts or when spawned
void AMyActor::BeginPlay()
{
    Super::BeginPlay();
}

// Called every frame
void AMyActor::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
}

// TakeDamage method definition
void AMyActor::TakeDamage(float DamageAmount)
{
    Health -= DamageAmount;
    if (Health <= 0)
    {
        // Handle actor death
    }
}

Integrando Clases C++ con Blueprints

Una de las ventajas de Unreal Engine es la capacidad de integrar C++ con Blueprints. Esto permite a los diseñadores de juegos utilizar la lógica escrita en C++ dentro del editor de Blueprints.

Exponer Propiedades y Métodos a Blueprints

Para exponer propiedades y métodos a Blueprints, utilizamos las macros UPROPERTY y UFUNCTION.

  • UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats") permite que la propiedad Health sea editable y accesible desde Blueprints.
  • UFUNCTION(BlueprintCallable, Category = "Stats") permite que el método TakeDamage sea llamado desde Blueprints.

Ejemplo de Uso en Blueprints

  1. Abre el editor de Blueprints.
  2. Crea un nuevo Blueprint basado en AMyActor.
  3. En el editor de Blueprints, verás la propiedad Health y el método TakeDamage disponibles para su uso.

Ejercicio Práctico

Ejercicio

  1. Crea una nueva clase AEnemy que herede de AActor.
  2. Agrega una propiedad Health de tipo float inicializada a 150.0f.
  3. Agrega un método ReceiveDamage que reduzca Health en una cantidad especificada.
  4. Expón la propiedad y el método a Blueprints.
  5. Crea un Blueprint basado en AEnemy y utiliza el método ReceiveDamage en un evento de colisión.

Solución

Declaración de la Clase

// Enemy.h
#pragma once

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

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

public:
    // Constructor
    AEnemy();

protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public:
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    // Health property
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
    float Health;

    // ReceiveDamage method
    UFUNCTION(BlueprintCallable, Category = "Stats")
    void ReceiveDamage(float DamageAmount);
};

Definición de la Clase

// Enemy.cpp
#include "Enemy.h"

// Constructor
AEnemy::AEnemy()
{
    // Set this actor to call Tick() every frame.
    PrimaryActorTick.bCanEverTick = true;

    // Initialize Health
    Health = 150.0f;
}

// Called when the game starts or when spawned
void AEnemy::BeginPlay()
{
    Super::BeginPlay();
}

// Called every frame
void AEnemy::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
}

// ReceiveDamage method definition
void AEnemy::ReceiveDamage(float DamageAmount)
{
    Health -= DamageAmount;
    if (Health <= 0)
    {
        // Handle enemy death
    }
}

Conclusión

En este tema, has aprendido cómo crear y utilizar clases en C++ dentro de Unreal Engine. Has visto cómo declarar y definir propiedades y métodos, así como cómo exponerlos a Blueprints para su uso en el editor. Con esta base, estás preparado para crear estructuras de código más complejas y eficientes en tus proyectos de Unreal Engine.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados