Haddock - Unreal Library

"make a blue part"

"create a custom widget"

"make an npc that follows the player"

"wave simulator"

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

"create trigger when player interacts with a door"

"script to trigger score when player acheives it"

"custom camera shaking"

"script for moving the camera"

"custom particle system"

"teleport player from one place to other"

"create a zombie spawner"

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

"script for ripple effects on water"

"Make a slenderman like creature"

"script to create player picking up health"

"custom sound cue"

"make a blue part"

"create an inventory trigger"

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

"script for creating a starfield"

"display and hide texture on button click"

"dsj jkfds jfds bjnfnjsdnfjhsd"

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

"script for creating a custom terrain"

"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 zombie spawner"

"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 jump pad with blueprint"

"create a cube"

"creates an enemy dectection trigger"

"make a zombie"

"create a zombie spawner"

"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);
    }
}

"methods to control rotation of spacecraft"

"black background"

"make a gore script"

"make a Dismemberment and ragdoll script"

"script for when player triggers pickup function"

"make a sword"

"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
    }

"teleport player from one place to other"

"create a custom pawn"

"curtain control actions"

"move a star"

"script for placing a structure"

"create a dog"

"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 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);
}

"a lion"

"create a zombie spawner"

"change time of day"

"make a weather system"

"make a gore script"

"make an npc"

"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;
}

"create a zombie spawner"

"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);

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

"make a ghost"

"script that spawns a starcraft in space"

"script that updates the speed of the spacecraft"

"create a custom actor"

"water splashes on impact"

"create a enemy script"

"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 a Procedural Dismemberment script"

"create an intractable trigger"

"make a rocket"

"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);
}

"make a blue part in unreal"

"create a car"

"create under water effects"

"spawn a creature"

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

"boat bouncing in water"

"game mode"

"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
}}}

"script for teleporting the overlapping actor to another location"

"make a plane with only one wing"

"make light switch trigger when user enters sphere"

"make a sword"

"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;
}