Hi, I’m follow a tutorile on youtube to make an inventory : Crafting/Inventory System Tutorial in Unreal Engine - #1 - YouTube.
I followed the tutoriel and did what he said in but my code isn’t working but I don’t know why.
The following code is the character class :
#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "Engine/DataTable.h"
#include "Pickup.h"
#include "GameplayController.h"
#include "InvetoryCharacter.generated.h"
USTRUCT(BlueprintType)
struct FCraftingInfo : public FTableRowBase{
GENERATED_BODY()
public:
UPROPERTY(EditAnywhere, BLueprintReadWrite)
FName ComponentID;
UPROPERTY(EditAnywhere, BLueprintReadWrite)
FName ProductID;
UPROPERTY(EditAnywhere, BLueprintReadWrite)
bool bDestroyedItemA;
UPROPERTY(EditAnywhere, BLueprintReadWrite)
bool bDestroyItemB;
};
USTRUCT(BlueprintType)
struct FInventoryItem : public FTableRowBase {
GENERATED_BODY()
public:
FInventoryItem() {
Name = FText::FromString("Item");
Action = FText::FromString("Use");
Description = FText::FromString("Please enter a description for this item");
Value = 10;
}
UPROPERTY(EditAnywhere, BLueprintReadWrite)
FName ItemID;
UPROPERTY(EditAnywhere, BLueprintReadWrite)
TSubclassOf<class APickup> ItemPickup;
UPROPERTY(EditAnywhere, BLueprintReadWrite)
FText Name;
UPROPERTY(EditAnywhere, BLueprintReadWrite)
FText Action;
UPROPERTY(EditAnywhere, BLueprintReadWrite)
int32 Value;
UPROPERTY(EditAnywhere, BLueprintReadWrite)
UTexture2D* Thumbnail;
UPROPERTY(EditAnywhere, BLueprintReadWrite)
FText Description;
UPROPERTY(EditAnywhere, BLueprintReadWrite)
TArray<FCraftingInfo> CraftCombinations;
UPROPERTY(EditAnywhere, BLueprintReadWrite)
bool bCanBeUsed;
bool operator==(const FInventoryItem& Item)const {
if (ItemID == Item.ItemID)
return true;
else return false;
}
};
UCLASS(config=Game)
class AInvetoryCharacter : public ACharacter
{
GENERATED_BODY()
/** Camera boom positioning the camera behind the character */
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
class USpringArmComponent* CameraBoom;
/** Follow camera */
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
class UCameraComponent* FollowCamera;
public:
AInvetoryCharacter();
/** Base turn rate, in deg/sec. Other scaling may affect final turn rate. */
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Input)
float TurnRateGamepad;
protected:
void CheckForInteractables();
virtual void Tick(float DeltaTime) override;
/** Called for forwards/backward input */
void MoveForward(float Value);
/** Called for side to side input */
void MoveRight(float Value);
/**
* Called via input to turn at a given rate.
* @param Rate This is a normalized rate, i.e. 1.0 means 100% of desired turn rate
*/
void TurnAtRate(float Rate);
/**
* Called via input to turn look up/down at a given rate.
* @param Rate This is a normalized rate, i.e. 1.0 means 100% of desired turn rate
*/
void LookUpAtRate(float Rate);
/** Handler for when a touch input begins. */
void TouchStarted(ETouchIndex::Type FingerIndex, FVector Location);
/** Handler for when a touch input stops. */
void TouchStopped(ETouchIndex::Type FingerIndex, FVector Location);
protected:
// APawn interface
virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
// End of APawn interface
public:
/** Returns CameraBoom subobject **/
FORCEINLINE class USpringArmComponent* GetCameraBoom() const { return CameraBoom; }
/** Returns FollowCamera subobject **/
FORCEINLINE class UCameraComponent* GetFollowCamera() const { return FollowCamera; }
};
#include "InvetoryCharacter.h"
#include "Camera/CameraComponent.h"
#include "Components/CapsuleComponent.h"
#include "Components/InputComponent.h"
#include "Interactable.h"
#include "GameplayController.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "GameFramework/Controller.h"
#include "GameFramework/SpringArmComponent.h"
//////////////////////////////////////////////////////////////////////////
// AInvetoryCharacter
AInvetoryCharacter::AInvetoryCharacter()
{
// Set size for collision capsule
GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);
// set our turn rate for input
TurnRateGamepad = 50.f;
// Don't rotate when the controller rotates. Let that just affect the camera.
bUseControllerRotationPitch = false;
bUseControllerRotationYaw = false;
bUseControllerRotationRoll = false;
// Configure character movement
GetCharacterMovement()->bOrientRotationToMovement = true; // Character moves in the direction of input...
GetCharacterMovement()->RotationRate = FRotator(0.0f, 500.0f, 0.0f); // ...at this rotation rate
// Note: For faster iteration times these variables, and many more, can be tweaked in the Character Blueprint
// instead of recompiling to adjust them
GetCharacterMovement()->JumpZVelocity = 700.f;
GetCharacterMovement()->AirControl = 0.35f;
GetCharacterMovement()->MaxWalkSpeed = 500.f;
GetCharacterMovement()->MinAnalogWalkSpeed = 20.f;
GetCharacterMovement()->BrakingDecelerationWalking = 2000.f;
// Create a camera boom (pulls in towards the player if there is a collision)
CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
CameraBoom->SetupAttachment(RootComponent);
CameraBoom->TargetArmLength = 400.0f; // The camera follows at this distance behind the character
CameraBoom->bUsePawnControlRotation = true; // Rotate the arm based on the controller
// Create a follow camera
FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName); // Attach the camera to the end of the boom and let the boom adjust to match the controller orientation
FollowCamera->bUsePawnControlRotation = false; // Camera does not rotate relative to arm
// Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character)
// are set in the derived blueprint asset named ThirdPersonCharacter (to avoid direct content references in C++)
}
//////////////////////////////////////////////////////////////////////////
// Input
void AInvetoryCharacter::SetupPlayerInputComponent(class UInputComponent* 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("Move Forward / Backward", this, &AInvetoryCharacter::MoveForward);
PlayerInputComponent->BindAxis("Move Right / Left", this, &AInvetoryCharacter::MoveRight);
// We have 2 versions of the rotation bindings to handle different kinds of devices differently
// "turn" handles devices that provide an absolute delta, such as a mouse.
// "turnrate" is for devices that we choose to treat as a rate of change, such as an analog joystick
PlayerInputComponent->BindAxis("Turn Right / Left Mouse", this, &APawn::AddControllerYawInput);
PlayerInputComponent->BindAxis("Turn Right / Left Gamepad", this, &AInvetoryCharacter::TurnAtRate);
PlayerInputComponent->BindAxis("Look Up / Down Mouse", this, &APawn::AddControllerPitchInput);
PlayerInputComponent->BindAxis("Look Up / Down Gamepad", this, &AInvetoryCharacter::LookUpAtRate);
// handle touch devices
PlayerInputComponent->BindTouch(IE_Pressed, this, &AInvetoryCharacter::TouchStarted);
PlayerInputComponent->BindTouch(IE_Released, this, &AInvetoryCharacter::TouchStopped);
}
void AInvetoryCharacter::Tick(float DeltaTime) {
Super::Tick(DeltaTime);
CheckForInteractables();
}
void AInvetoryCharacter::CheckForInteractables() {
FHitResult HitResult;
FVector StartTrace = FollowCamera->GetComponentLocation();
FVector EndTrace = (FollowCamera->GetForwardVector() * 300) + StartTrace;
FCollisionQueryParams QueryParams;
QueryParams.AddIgnoredActor(this);
AGameplayController* Control = Cast<AGameplayController>(GetController());
if (GetWorld()->LineTraceSingleByChannel(HitResult, StartTrace, EndTrace, ECC_Visibility, QueryParams)&& Control) {
if (AInteractable* Interactable = Cast<AInteractable>(HitResult.GetActor())) {
Control->CurrentInteractable = Interactable;
return;
}
}
else {
Control->CurrentInteractable = nullptr;
return;
}
}
void AInvetoryCharacter::TouchStarted(ETouchIndex::Type FingerIndex, FVector Location)
{
Jump();
}
void AInvetoryCharacter::TouchStopped(ETouchIndex::Type FingerIndex, FVector Location)
{
StopJumping();
}
void AInvetoryCharacter::TurnAtRate(float Rate)
{
// calculate delta for this frame from the rate information
AddControllerYawInput(Rate * TurnRateGamepad * GetWorld()->GetDeltaSeconds());
}
void AInvetoryCharacter::LookUpAtRate(float Rate)
{
// calculate delta for this frame from the rate information
AddControllerPitchInput(Rate * TurnRateGamepad * GetWorld()->GetDeltaSeconds());
}
void AInvetoryCharacter::MoveForward(float Value)
{
if ((Controller != nullptr) && (Value != 0.0f))
{
// find out which way is forward
const FRotator Rotation = Controller->GetControlRotation();
const FRotator YawRotation(0, Rotation.Yaw, 0);
// get forward vector
const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
AddMovementInput(Direction, Value);
}
}
void AInvetoryCharacter::MoveRight(float Value)
{
if ( (Controller != nullptr) && (Value != 0.0f) )
{
// find out which way is right
const FRotator Rotation = Controller->GetControlRotation();
const FRotator YawRotation(0, Rotation.Yaw, 0);
// get right vector
const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
// add movement in that direction
AddMovementInput(Direction, Value);
}
}
Controller :
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/PlayerController.h"
#include "Interactable.h"
#include "GameplayGameMode.h"
#include "GameplayController.generated.h"
/**
*
*/
UCLASS()
class INVETORY_API AGameplayController : public APlayerController
{
GENERATED_BODY()
public:
UPROPERTY(BlueprintReadWrite, VisibleAnywhere)
AInteractable* CurrentInteractable;
};
there is nothing in .cpp
In the gamemode class there is just the class and nothing else and the same for the .cpp
Interactable :
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Interactable.generated.h"
UCLASS()
class INVETORY_API AInteractable : public AActor
{
GENERATED_BODY()
public:
// Sets default values for this actor's properties
AInteractable();
// Called when the game starts or when spawned
virtual void BeginPlay() override;
//La fonction va etre appele quand le joueur interagit avec l'interactible
//Cette fonction est marquer comme BlueprintImplementable ce qui designe que les designers pourront implementer des fonctions personnaliser dans les blueprints
UFUNCTION(BlueprintImplementableEvent)
void Interact(APlayerController* Controller);
UPROPERTY(EditDefaultsOnly)
FString Name;
UPROPERTY(EditDefaultsOnly)
FString Action;
UFUNCTION(BlueprintCallable, Category = "Pickup")
FString GetUseText() const;
};
#include "Interactable.h"
// Sets default values
AInteractable::AInteractable()
{
Name = "Name not see";
Action = "Interact";
}
// Called when the game starts or when spawned
void AInteractable::BeginPlay()
{
Super::BeginPlay();
}
FString AInteractable::GetUseText() const {
return FString::Printf(TEXT("%s :: Press E to %s"), *Name, *Action);
}
type or paste code here
#include "Interactable.h"
// Sets default values
AInteractable::AInteractable()
{
Name = "Name not see";
Action = "Interact";
}
// Called when the game starts or when spawned
void AInteractable::BeginPlay()
{
Super::BeginPlay();
}
FString AInteractable::GetUseText() const {
return FString::Printf(TEXT("%s :: Press E to %s"), *Name, *Action);
}
Pickup :
#pragma once
#include "CoreMinimal.h"
#include "Interactable.h"
#include "Pickup.generated.h"
/**
*
*/
UCLASS()
class INVETORY_API APickup : public AInteractable
{
GENERATED_BODY()
public:
APickup();
protected:
UPROPERTY(EditAnywhere)
UStaticMeshComponent* PickupMesh;
UPROPERTY(EditAnywhere, BlueprintReadWrite)
FName ItemID;
};
#include "Pickup.h"
APickup::APickup() {
PickupMesh = CreateDefaultSubobject<UStaticMeshComponent>("PickupMesh");
ItemID = FName("Please enter an ID");
}
also there is a little blueprint wich is bind to a text and print the name of the Interactble and is action (pickup, push…) :
and more info :
thank you in advance
what is it that isn’t working? if it is not compilling anymore paste the output log here please
He might print the name of the pickup but he doesn’t
If it’s not compiling, this might be the issue (the upper case L). I haven’t checked all of the code looking for more real problems though.