Why can't I call onFire(); - c++

Question

I'm trying to implement weapon firing in my game!
My inheritance chain looks like this:
ACharacter -> AMainCharacter
AActor -> AWeapon -> ALaserGun
I'm trying to call a function in the ALaserGun class, but for some reason Weapon isn't of type ALaserGun. How can I use SpawnActor<>() to spawn an actor that's the same type as WeaponAtSpawnClass if I'm setting WeaponAtSpawnClass in blueprint? Right now, I'm spawning an AWeapon actor. I want to spawn a child of AWeapon which has OnFire() in it. The type of Weapon being the class stored in WeaponAtSpawnClass.
Some things that I've noted that might be causing the issue:
Weapon in MainCharacter.h is of type AWeapon*
SpawnActor<>() in Main Character.cpp uses AWeapon as the spawned type.
Would I have to change AWeapon in these statements to something else?
Here's my code:
MainCharacter.h
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MainCharacter.generated.h"
class AWeapon;
UCLASS()
class TEST_API AMainCharacter : public ACharacter
{
GENERATED_BODY()
public:
AWeapon* Weapon;
UPROPERTY(EditAnywhere)
TSubclassOf<AWeapon> WeaponAtSpawnClass;
void OnFire();
protected:
// Called when the game starts or when spawned
virtual void BeginPlay() override;
public:
// Called to bind functionality to input
virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
MainCharacter.cpp
#include "MainCharacter.h"
#include "Weapon.h"
// Called when the game starts or when spawned
void AMainCharacter::BeginPlay()
{
Super::BeginPlay();
Weapon = GetWorld()->SpawnActor<AWeapon>(WeaponAtSpawnClass);
}
void AMainCharacter::OnFire()
{
Weapon->OnFire();
}
// Called to bind functionality to input
void AMainCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
Super::SetupPlayerInputComponent(PlayerInputComponent);
PlayerInputComponent->BindAction("Fire", IE_Pressed, this, &AMainCharacter::OnFire);
}
Weapon.h
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Weapon.generated.h"
UCLASS()
class TEST_API AWeapon : public AActor
{
GENERATED_BODY()
};
There is no code in Weapon.cpp
LaserGun.h
#pragma once
#include "CoreMinimal.h"
#include "Weapon.h"
#include "LaserGun.generated.h"
UCLASS()
class TEST_API ALaserGun : public AWeapon
{
GENERATED_BODY()
public:
void OnFire();
};
LaserGun.cpp
#include "LaserGun.h"
void ALaserGun::OnFire()
{
UE_LOG(LogTemp, Warning, TEXT("Gun fired"))
}

Answer 1

AWeapon* Weapon; declares a pointer to any AWeapon. How whould the compiler know, that it points to a instance of a class that has some specific method?
Of course you could start casting Weapon to ALaserGun, but that's going to result in a mess. The better alternative is to declare the method in the interface AWeapon:
UCLASS()
class TEST_API AWeapon : public AActor
{
GENERATED_BODY()
public:
virtual OnFire() = 0;
};
And for good style declare that you override that method:
UCLASS()
class TEST_API ALaserGun : public AWeapon
{
GENERATED_BODY()
public:
void OnFire() override;
};
Naming is of course up to you, for example, if not every weapon can fire, name the method OnAttack or something, then call OnFire from OnAttack or something like that.