Haddock - Unreal Library

"script for moving the camera"

"blueprint class for a character that can jump, move and animate in a 3D platformer"

"Implement custom animation montage: extend UAnimMontage to play on a skeletal mesh. Set properties (blend times, reverse) in constructor, override Evaluate for custom evaluation logic"

"create a weather system"

void UWeatherSystem::ApplyWeatherEffects(EWeatherType WeatherType)
{
    // Clear any existing weather effects
    WeatherEffects.Empty();

switch (WeatherType)
    {
        case EWeatherType::Sunny:
        {
            // Add a sunny skybox
            FWeatherEffect SunnySkybox;
            SunnySkybox.Type = EWeatherEffectType::Skybox;
            SunnySkybox.Skybox = LoadObject<UTexture2D>(NULL, TEXT("/Game/Textures/Skyboxes/Sunny.Sunny"));
            WeatherEffects.Add(SunnySkybox);
            break;
        }
        case EWeatherType::Rainy:
        {
            // Add a rainy skybox
            FWeatherEffect RainySkybox;
            RainySkybox.Type = EWeatherEffectType::Skybox;
            RainySkybox.Skybox = LoadObject<UTexture2D>(NULL, TEXT("/Game/Textures/Skyboxes/Rainy.Rainy"));
            WeatherEffects.Add(RainySkybox);

// Add rain particle system
            FWeatherEffect RainParticles;
            RainParticles.Type = EWeatherEffectType::ParticleSystem;
            RainParticles.ParticleSystem = LoadObject<UParticleSystem>(NULL, TEXT("/Game/Particles/Rain.Rain"));
            WeatherEffects.Add(RainParticles);
            break;
        }
        // Add more weather types here
    }

"make a gore script"

"create a car"

"script that updates the speed of the spacecraft"

"create under water effects"

"move a star"

"water splashes on impact"

"Create a realistic physics-based player movement system which allows for smooth transitioning between moving and standing, while also animating walking, running and idle animations to be similar to real life human behavior."

// Header file
UCLASS()
class YOURGAME_API ARealisticCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    ARealisticCharacter();

protected:
    virtual void BeginPlay() override;
    virtual void Tick(float DeltaTime) override;

UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Movement")
    float WalkSpeed;

UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Movement")
    float RunSpeed;

UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Animation")
    UAnimMontage* WalkAnimation;

UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Animation")
    UAnimMontage* RunAnimation;

UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Animation")
    UAnimMontage* IdleAnimation;

UFUNCTION()
    void MoveForward(float Value);

UFUNCTION()
    void MoveRight(float Value);

UFUNCTION()
    void StartRunning();

UFUNCTION()
    void StopRunning();

private:
    bool bIsRunning;
};

// Source file
ARealisticCharacter::ARealisticCharacter()
{
    PrimaryActorTick.bCanEverTick = true;

WalkSpeed = 300.0f;
    RunSpeed = 600.0f;
    bIsRunning = false;
}

void ARealisticCharacter::BeginPlay()
{
    Super::BeginPlay();

GetCharacterMovement()->MaxWalkSpeed = WalkSpeed;
}

void ARealisticCharacter::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

// Update animation based on movement speed
    float Speed = GetVelocity().Size();
    UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance();

if (Speed > 0.0f)
    {
        if (bIsRunning)
        {
            AnimInstance->Montage_Play(RunAnimation);
        }
        else
        {
            AnimInstance->Montage_Play(WalkAnimation);
        }
    }
    else
    {
        AnimInstance->Montage_Play(IdleAnimation);
    }
}

void ARealisticCharacter::MoveForward(float Value)
{
    if (Controller && Value != 0.0f)
    {
        const FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::X);
        AddMovementInput(Direction, Value);
    }
}

void ARealisticCharacter::MoveRight(float Value)
{
    if (Controller && Value != 0.0f)
    {
        const FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::Y);
        AddMovementInput(Direction, Value);
    }
}

void ARealisticCharacter::StartRunning()
{
    bIsRunning = true;
    GetCharacterMovement()->MaxWalkSpeed = RunSpeed;
}

void ARealisticCharacter::StopRunning()
{
    bIsRunning = false;
    GetCharacterMovement()->MaxWalkSpeed = WalkSpeed;
}

"make light switch trigger when user enters sphere"

"create a jump pad with blueprint"

"create a circle"

// Create a circle in Unreal
UStaticMeshComponent* ACircleActor::CreateCircle(float Radius, int32 NumSides)
{
    UStaticMeshComponent* CircleMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Circle Mesh Component"));
    CircleMesh->SetupAttachment(RootComponent);

TArray<FVector> Vertices;
    float AngleStep = 360.0f / NumSides;

for (int32 i = 0; i < NumSides; i++)
    {
        float Angle = i * AngleStep;
        FVector Vertex = FVector(FMath::Cos(FMath::DegreesToRadians(Angle)) * Radius, FMath::Sin(FMath::DegreesToRadians(Angle)) * Radius, 0.0f);
        Vertices.Add(Vertex);
    }

// Create a procedural mesh and set its vertices
    UProceduralMeshComponent* ProceduralMesh = CreateDefaultSubobject<UProceduralMeshComponent>(TEXT("Procedural Mesh Component"));
    ProceduralMesh->SetupAttachment(CircleMesh);
    ProceduralMesh->CreateMeshSection(0, Vertices, TArray<int32>(), TArray<FVector>(), TArray<FVector2D>(), TArray<FColor>(), TArray<FProcMeshTangent>(), true);

return CircleMesh;
}

"create a dog"

"teleport player from one place to other"

"Create a grid inventory system"

// Grid Inventory System

UCLASS()
class UGridInventory : public UObject
{
    GENERATED_BODY()

public:
    UGridInventory();

UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Inventory")
    int32 GridRows;

UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Inventory")
    int32 GridColumns;

UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Inventory")
    TArray<UInventoryItem*> InventoryItems;

UFUNCTION(BlueprintCallable, Category = "Inventory")
    bool AddItemToInventory(UInventoryItem* Item);

UFUNCTION(BlueprintCallable, Category = "Inventory")
    bool RemoveItemFromInventory(UInventoryItem* Item);

UFUNCTION(BlueprintCallable, Category = "Inventory")
    UInventoryItem* GetItemAtGridPosition(int32 Row, int32 Column);

private:
    int32 GetInventoryIndex(int32 Row, int32 Column) const;
};

UGridInventory::UGridInventory()
{
    GridRows = 5;
    GridColumns = 5;
    InventoryItems.SetNumZeroed(GridRows * GridColumns);
}

bool UGridInventory::AddItemToInventory(UInventoryItem* Item)
{
    for (int32 i = 0; i < InventoryItems.Num(); i++)
    {
        if (InventoryItems[i] == nullptr)
        {
            InventoryItems[i] = Item;
            return true;
        }
    }
    return false;
}

bool UGridInventory::RemoveItemFromInventory(UInventoryItem* Item)
{
    for (int32 i = 0; i < InventoryItems.Num(); i++)
    {
        if (InventoryItems[i] == Item)
        {
            InventoryItems[i] = nullptr;
            return true;
        }
    }
    return false;
}

UInventoryItem* UGridInventory::GetItemAtGridPosition(int32 Row, int32 Column)
{
    int32 Index = GetInventoryIndex(Row, Column);
    if (Index != INDEX_NONE)
    {
        return InventoryItems[Index];
    }
    return nullptr;
}

int32 UGridInventory::GetInventoryIndex(int32 Row, int32 Column) const
{
    if (Row >= 0 && Row < GridRows && Column >= 0 && Column < GridColumns)
    {
        return Row * GridColumns   Column;
    }
    return INDEX_NONE;
}

"create trigger when player interacts with a door"

"create a zombie spawner"

"make an npc"

"create a zombie spawner"

"make a ghost"

"display and hide texture on button click"

"create a custom widget"

"movement system"

// Implement a basic movement system in Unreal

// Add this to your character's header file
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movement")
float MovementSpeed;

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movement")
float RotationSpeed;

// Add this to your character's source file
void AMyCharacter::MoveForward(float Value)
{
    FVector Forward = GetActorForwardVector();
    AddMovementInput(Forward, Value * MovementSpeed * GetWorld()->GetDeltaSeconds());
}

void AMyCharacter::MoveRight(float Value)
{
    FVector Right = GetActorRightVector();
    AddMovementInput(Right, Value * MovementSpeed * GetWorld()->GetDeltaSeconds());
}

void AMyCharacter::Turn(float Value)
{
    FRotator NewRotation = GetActorRotation();
    NewRotation.Yaw  = Value * RotationSpeed * GetWorld()->GetDeltaSeconds();
    SetActorRotation(NewRotation);
}

// Add this to your character's BeginPlay() method
InputComponent->BindAxis("MoveForward", this, &AMyCharacter::MoveForward);
InputComponent->BindAxis("MoveRight", this, &AMyCharacter::MoveRight);
InputComponent->BindAxis("Turn", this, &AMyCharacter::Turn);

"script for placing a structure"

"make a sword"

"make a plane with only one wing"

"create a cube"

"script for teleporting the overlapping actor to another location"

"boat bouncing in water"

"create a custom actor"

"creates an enemy dectection trigger"

"teleport player from one place to other, add comments to code"

"custom particle system"

"blueprint class for a character that can jump, move and animate in a 3D platformer"

"make a blue part"

"custom camera shaking"

"make a blue part"

"make a sword"

"make a weather system"

UWeatherSystem::UWeatherSystem()
{
    // Set this component to be initialized when the game starts, and to be ticked every frame.  You can turn these features
    // off to improve performance if you don't need them.
    PrimaryComponentTick.bCanEverTick = true;

// Set the default weather type
    CurrentWeatherType = EWeatherType::Sunny;
}

void UWeatherSystem::BeginPlay()
{
    Super::BeginPlay();

// Apply the default weather type
    ApplyWeatherEffects(CurrentWeatherType);
}

void UWeatherSystem::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
    Super::TickComponent(DeltaTime, TickType, ThisTickFunction);

// Check if the weather type has changed
    if (CurrentWeatherType != TargetWeatherType)
    {
        // Fade out the current weather effects
        FadeOutWeatherEffects(DeltaTime);

// When the fade out is complete, apply the new weather type
        if (WeatherFadeTimer <= 0.0f)
        {
            CurrentWeatherType = TargetWeatherType;
            ApplyWeatherEffects(CurrentWeatherType);
        }
    }
}

void UWeatherSystem::SetWeatherType(EWeatherType NewWeatherType)
{
    TargetWeatherType = NewWeatherType;
    WeatherFadeTimer = WeatherFadeTime;
}

"Make a slenderman like creature"

"create an advanced hot air balloon"

//HotAirBalloon Class Declaration
#pragma once

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

UCLASS()
class EXAMPLEPROJECT_API AHotAirBalloon : public AActor
{
        GENERATED_BODY()

public:        
        // Sets default values for this actor's properties
        AHotAirBalloon();

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

// Reference to the hot air balloon mesh component
        UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Hot Air Balloon")
        UStaticMeshComponent* BalloonMesh;

// Reference to the hot air balloon particle system component
        UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Hot Air Balloon")
        UParticleSystemComponent* FlameParticles;

// Maximum height that the hot air balloon can reach
        UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Hot Air Balloon")
        float MaxHeight;

// Speed at which the hot air balloon ascends and descends
        UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Hot Air Balloon")
        float VerticalSpeed;

private:
        // Private variables for handling the hot air balloon's movement
        float CurrentHeight;
        bool bIsAscending;
};
//HotAirBalloon Class Implementation
#include "HotAirBalloon.h"

// Sets default values
AHotAirBalloon::AHotAirBalloon()
{
         // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
        PrimaryActorTick.bCanEverTick = true;

// Create and attach the hot air balloon mesh component
        BalloonMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("BalloonMesh"));
        RootComponent = BalloonMesh;

// Create and attach the hot air balloon particle system component
        FlameParticles = CreateDefaultSubobject<UParticleSystemComponent>(TEXT("FlameParticles"));
        FlameParticles->SetupAttachment(RootComponent);

// Initialize variables
        MaxHeight = 1000.0f;
        VerticalSpeed = 50.0f;
        CurrentHeight = GetActorLocation().Z;
        bIsAscending = true;
}

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

// Get the current location of the hot air balloon
        FVector CurrentLocation = GetActorLocation();

// If the hot air balloon is ascending, increase its height
        if (bIsAscending)
        {
                CurrentHeight  = VerticalSpeed * DeltaTime;
                if (CurrentHeight >= MaxHeight)
                {
                        bIsA
}}}

"spawn a creature"

"create a button that when clicked goes to fb.com"

"make an npc that follows the player"

"curtain control actions"

"Create a smooth movement animation system"

// Smooth Movement Animation System in Unreal

// In your character's header file
UCLASS()
class YOURGAME_API AYourCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    // Sets default values for this character's properties
    AYourCharacter();

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

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

// Smooth movement function
    void SmoothMovement(float DeltaTime);

// Movement speed
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movement")
    float MovementSpeed;

// Target location
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movement")
    FVector TargetLocation;

private:
    // Current location
    FVector CurrentLocation;

// Lerp alpha
    float LerpAlpha;
};

// In your character's source file
AYourCharacter::AYourCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AYourCharacter::BeginPlay()
{
    Super::BeginPlay();
    CurrentLocation = GetActorLocation();
    LerpAlpha = 0.0f;
}

void AYourCharacter::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
    SmoothMovement(DeltaTime);
}

void AYourCharacter::SmoothMovement(float DeltaTime)
{
    if (LerpAlpha < 1.0f)
    {
        LerpAlpha  = FMath::Clamp(LerpAlpha + DeltaTime * MovementSpeed, 0.0f, 1.0f);
        FVector NewLocation = FMath::Lerp(CurrentLocation, TargetLocation, LerpAlpha);
        SetActorLocation(NewLocation);
    }
}

"Create a Player that is in third person with W, A, S, D controls"

// Create a Player
APlayer::APlayer()
{
    // Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;

// Set the size of our collision capsule.
    GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);

// Create a camera boom attached to the root (capsule)
    CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
    CameraBoom->SetupAttachment(RootComponent);
    CameraBoom->bAbsoluteRotation = true; // Don't want arm to rotate when character does
    CameraBoom->TargetArmLength = 500.f;
    CameraBoom->RelativeRotation = FRotator(-60.f, 0.f, 0.f);
    CameraBoom->bDoCollisionTest = false; // Don't want to pull camera in when it collides with level

// Create a camera and attach to boom
    SideViewCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("SideViewCamera"));
    SideViewCameraComponent->SetupAttachment(CameraBoom, USpringArmComponent::SocketName);
    SideViewCameraComponent->bUsePawnControlRotation = false; // Camera does not rotate relative to arm

// Configure character movement
    GetCharacterMovement()->bOrientRotationToMovement = true; // Face in the direction we are moving..
    GetCharacterMovement()->RotationRate = FRotator(0.0f, 720.0f, 0.0f); // ...at this rotation rate
    GetCharacterMovement()->GravityScale = 2.f;
    GetCharacterMovement()->AirControl = 0.80f;
    GetCharacterMovement()->JumpZVelocity = 1000.f;
    GetCharacterMovement()->GroundFriction = 3.f;
    GetCharacterMovement()->MaxWalkSpeed = 600.f;
    GetCharacterMovement()->MaxFlySpeed = 600.f;
}

// Called to bind functionality to input
void APlayer::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);

// Set up gameplay key bindings
    check(PlayerInputComponent);
    PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &ACharacter::Jump);
    PlayerInputComponent->BindAction("Jump", IE_Released, this, &ACharacter::StopJumping);
    PlayerInputComponent->BindAxis("MoveRight", this, &APlayer::MoveRight);
}

void APlayer::MoveRight(float Value)
{
    // add movement in that direction
    AddMovementInput(FVector(0.f,-1.f,0.f), Value);
}

"Create a physics based movement system for players that simulates realistic human movement behavior"

// Create a physics-based movement system for players that simulates realistic human movement behavior in Unreal

// In your custom PlayerCharacter class header file (e.g., MyPlayerCharacter.h), add the following properties and functions:

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movement")
float WalkSpeed;

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movement")
float RunSpeed;

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movement")
float JumpForce;

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movement")
float AirControl;

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movement")
bool bIsRunning;

UFUNCTION(BlueprintCallable, Category = "Movement")
void MoveForward(float Value);

UFUNCTION(BlueprintCallable, Category = "Movement")
void MoveRight(float Value);

UFUNCTION(BlueprintCallable, Category = "Movement")
void Jump();

UFUNCTION(BlueprintCallable, Category = "Movement")
void StopJumping();

UFUNCTION(BlueprintCallable, Category = "Movement")
void StartRunning();

UFUNCTION(BlueprintCallable, Category = "Movement")
void StopRunning();

// In your custom PlayerCharacter class source file (e.g., MyPlayerCharacter.cpp), implement the functions:

void AMyPlayerCharacter::MoveForward(float Value)
{
    if (Value != 0.0f)
    {
        // Add movement input along the character's forward vector
        AddMovementInput(GetActorForwardVector(), Value);
    }
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    if (Value != 0.0f)
    {
        // Add movement input along the character's right vector
        AddMovementInput(GetActorRightVector(), Value);
    }
}

void AMyPlayerCharacter::Jump()
{
    if (GetCharacterMovement()->IsMovingOnGround())
    {
        FVector JumpImpulse = FVector(0, 0, JumpForce);
        GetCharacterMovement()->AddImpulse(JumpImpulse, true);
    }
}

void AMyPlayerCharacter::StopJumping()
{
    // Override this function if you need custom behavior when stopping a jump
}

void AMyPlayerCharacter::StartRunning()
{
    bIsRunning = true;
    GetCharacterMovement()->MaxWalkSpeed = RunSpeed;
}

void AMyPlayerCharacter::StopRunning()
{
    bIsRunning = false;
    GetCharacterMovement()->MaxWalkSpeed = WalkSpeed;
}

// In your custom PlayerController class, bind the input actions to the functions:

void AMyPlayerController::SetupInputComponent()
{
    Super::SetupInputComponent();

InputComponent->BindAxis("MoveForward", this, &AMyPlayerController::MoveForward);
    InputComponent->BindAxis("MoveRight", this, &AMyPlayerController::MoveRight);
    InputComponent->BindAction("Jump", IE_Pressed, this, &AMyPlayerController::Jump);
    InputComponent->BindAction("Jump", IE_Released, this, &AMyPlayerController::StopJumping);
    InputComponent->BindAction("Run", IE_Pressed, this, &AMyPlayerController::StartRunning);
    InputComponent->BindAction("Run", IE_Released, this, &AMyPlayerController::StopRunning);
}

"make a blue part in unreal"

"create a enemy script"

"change time of day"

"custom sound cue"

"dsj jkfds jfds bjnfnjsdnfjhsd"

"create an inventory trigger"

"make a gore script"

"when triggered by a player, flips the player's gravity"

"create an intractable trigger"

"create a zombie spawner"

"methods to control rotation of spacecraft"

"create a zombie spawner"

"script that spawns a starcraft in space"

"make a weather system"

"black background"

"script for when player triggers pickup function"

"script to trigger score when player acheives it"

"script to create player picking up health"

"Create an animated player movement system that simulates a real human"

// Header file
UCLASS()
class YOURGAME_API APlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    APlayerCharacter();

// Movement Input
    void MoveForward(float Value);
    void MoveRight(float Value);

protected:
    // Animation Instances
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Animations")
    class UAnimMontage* WalkAnimation;

UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Animations")
    class UAnimMontage* RunAnimation;

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

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

// Called to bind functionality to input
    virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
};

// Source file
APlayerCharacter::APlayerCharacter()
{
    // Set this character to call Tick() every frame.
    PrimaryActorTick.bCanEverTick = true;
}

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

void APlayerCharacter::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
}

void APlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);

// Bind movement input
    PlayerInputComponent->BindAxis("MoveForward", this, &APlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &APlayerCharacter::MoveRight);
}

void APlayerCharacter::MoveForward(float Value)
{
    if (Value != 0.0f)
    {
        // Determine animation to use based on movement speed
        UAnimMontage* AnimationToPlay = (GetVelocity().Size() > WalkRunThreshold) ? RunAnimation : WalkAnimation;

// Play the animation if it's not already playing
        if (!GetMesh()->GetAnimInstance()->Montage_IsPlaying(AnimationToPlay))
        {
            GetMesh()->GetAnimInstance()->Montage_Play(AnimationToPlay);
        }

// Add movement input
        AddMovementInput(GetActorForwardVector(), Value);
    }
    else
    {
        // Stop the animation if it's playing
        GetMesh()->GetAnimInstance()->Montage_Stop(0.2f, WalkAnimation);
        GetMesh()->GetAnimInstance()->Montage_Stop(0.2f, RunAnimation);
    }
}

void APlayerCharacter::MoveRight(float Value)
{
    if (Value != 0.0f)
    {
        // Determine animation to use based on movement speed
        UAnimMontage* AnimationToPlay = (GetVelocity().Size() > WalkRunThreshold) ? RunAnimation : WalkAnimation;

// Play the animation if it's not already playing
        if (!GetMesh()->GetAnimInstance()->Montage_IsPlaying(AnimationToPlay))
        {
            GetMesh()->GetAnimInstance()->Montage_Play(AnimationToPlay);
        }

// Add movement input
        AddMovementInput(GetActorRightVector(), Value);
    }
    else
    {
        // Stop the animation if it's playing
        GetMesh()->GetAnimInstance()->Montage_Stop(0.2f, WalkAnimation);
        GetMesh()->GetAnimInstance()->Montage_Stop(0.2f, RunAnimation);
    }
}

"make a blue part"

"create a custom pawn"

"make a Procedural Dismemberment script"

"game mode"

"script for creating a starfield"

"script for ripple effects on water"

"make a rocket"

"a lion"

"script for creating a custom terrain"

"door that opens when the player comes close and has a trigger volume"

"make a Dismemberment and ragdoll script"

"make a zombie"

"wave simulator"

"teleport player from one place to other"