Shooter Help

Development Programming & Scripting C++
1

Hi guys, I need your help to understand a few things.

I’m currently working on an multiplayer FPS, so I using the the shooter game as source code.

What I do not understand is how weapons are attach to the character. I can 't find anywhere how they did it. Also I paste the original code, and for some reasons this doesn’t work for me.
Either the weapon mesh is attach to the first person view, or in the third person view, but never in both.

So what do I miss ? And where in shooter game are info to adjust the relative location for each weapon ?

thanx

2

Here is my character code :
// Fill out your copyright notice in the Description page of Project Settings.

#include “TOUnderFire.h”
#include “TOCharacter.h”
#include “UnrealNetwork.h”
#include “Player/BasePlayerState.h”

// Sets default values
ATOCharacter::ATOCharacter(const FObjectInitializer & ObjectInitializer)
{
// Set size for collision capsule
GetCapsuleComponent()->InitCapsuleSize(55.f, 96.0f);

// set our turn rates for input
BaseTurnRate = 45.f;
BaseLookUpRate = 45.f;

// Create a CameraComponent	
FirstPersonCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
FirstPersonCameraComponent->SetupAttachment(GetCapsuleComponent());
//FirstPersonCameraComponent->RelativeLocation = FVector(-39.56f, 1.75f, 64.f); // Position the camera
FirstPersonCameraComponent->bUsePawnControlRotation = true;

// Create a mesh component that will be used when being viewed from a '1st person' view (when controlling this pawn)
Mesh1P = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("CharacterMesh1P"));
Mesh1P->SetOnlyOwnerSee(true);
Mesh1P->SetupAttachment(GetCapsuleComponent());
Mesh1P->bCastDynamicShadow = false;
Mesh1P->CastShadow = false;

//Mesh1P->RelativeRotation = FRotator(1.9f, -19.19f, -160.f);
//Mesh1P->RelativeLocation = FVector(-0.5f, -4.4f, -155.7f);

/*// Create a gun mesh component
FP_Gun = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FP_Gun"));
FP_Gun->SetOnlyOwnerSee(true);			// only the owning player will see this mesh
FP_Gun->bCastDynamicShadow = false;
FP_Gun->CastShadow = false;
// FP_Gun->SetupAttachment(Mesh1P, TEXT("GripPoint"));
FP_Gun->SetupAttachment(RootComponent);


// Create a gun mesh component for 3rdPersonn
TP_Gun = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("TP_Gun"));
TP_Gun-> SetOnlyOwnerSee(false);// only the others player will see this mesh
TP_Gun->bCastDynamicShadow = true;
TP_Gun->CastShadow = true;
// FP_Gun->SetupAttachment(Mesh1P, TEXT("GripPoint"));
TP_Gun->SetupAttachment(GetMesh());
*/
FP_MuzzleLocation = CreateDefaultSubobject<USceneComponent>(TEXT("MuzzleLocation"));
//FP_MuzzleLocation->SetupAttachment(FP_Gun);
FP_MuzzleLocation->SetRelativeLocation(FVector(0.2f, 48.4f, -10.6f));



HealthMax = 100;

}

void ATOCharacter::PostInitializeComponents()
{
Super::PostInitializeComponents();

if (Role == ROLE_Authority)
{
	Health = HealthMax;
	SpawnDefaultInventory();
}

// set initial mesh visibility (3rd person view)
/*UpdatePawnMeshes();

// create material instance for setting team colors (3rd person view)
for (int32 iMat = 0; iMat < GetMesh()->GetNumMaterials(); iMat++)
{
	MeshMIDs.Add(GetMesh()->CreateAndSetMaterialInstanceDynamic(iMat));
}*/

// play respawn effects
if (GetNetMode() != NM_DedicatedServer)
{
	if (RespawnFX)
	{
		UGameplayStatics::SpawnEmitterAtLocation(this, RespawnFX, GetActorLocation(), GetActorRotation());
	}

	if (RespawnSound)
	{
		UGameplayStatics::PlaySoundAtLocation(this, RespawnSound, GetActorLocation());
	}
}

}

void ATOCharacter::Tick(float DeltaSeconds)
{
Super::Tick(DeltaSeconds);

}

void ATOCharacter::Destroyed()
{
Super::Destroyed();
DestroyInventory();
}

void ATOCharacter::BeginPlay()
{
// Call the base class
Super::BeginPlay();

//Attach gun mesh component to Skeleton, doing it here because the skeleton is not yet created in the constructor
//FP_Gun->AttachToComponent(Mesh1P, FAttachmentTransformRules(EAttachmentRule::SnapToTarget, true), TEXT("WeaponSocket"));
Mesh1P->SetHiddenInGame(false, true);

//TP_Gun->AttachToComponent(GetMesh(), FAttachmentTransformRules(EAttachmentRule::SnapToTarget, true), TEXT("WeaponSocket"));
GetMesh()->SetHiddenInGame(false, true);
Reset();

}

//////////////////////////////////////////////////////////////////////////////////////////
//Mov & Inputs

void ATOCharacter::MoveForward(float Value)
{
if (Value != 0.0f)
{
// add movement in that direction
AddMovementInput(GetActorForwardVector(), Value);
}
}

void ATOCharacter::MoveRight(float Value)
{
if (Value != 0.0f)
{
// add movement in that direction
AddMovementInput(GetActorRightVector(), Value);
}
}

void ATOCharacter::TurnAtRate(float Rate)
{
// calculate delta for this frame from the rate information
AddControllerYawInput(Rate * BaseTurnRate * GetWorld()->GetDeltaSeconds());
}

void ATOCharacter::LookUpAtRate(float Rate)
{
// calculate delta for this frame from the rate information
AddControllerPitchInput(Rate * BaseLookUpRate * GetWorld()->GetDeltaSeconds());
}

// Called to bind functionality to input
void ATOCharacter::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("MoveForward", this, &ATOCharacter::MoveForward);
PlayerInputComponent->BindAxis("MoveRight", this, &ATOCharacter::MoveRight);


PlayerInputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);
PlayerInputComponent->BindAxis("TurnRate", this, &ATOCharacter::TurnAtRate);
PlayerInputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);
PlayerInputComponent->BindAxis("LookUpRate", this, &ATOCharacter::LookUpAtRate);


PlayerInputComponent->BindAction("NextWeapon", IE_Pressed, this, &ATOCharacter::OnNextWeapon);
PlayerInputComponent->BindAction("PrevWeapon", IE_Pressed, this, &ATOCharacter::OnPrevWeapon);

}

//////////////////////////////////////////////////////////////////////////////
//

void ATOCharacter::GetLifetimeReplicatedProps(TArray< FLifetimeProperty > & OutLifetimeProps) const
{
Super::GetLifetimeReplicatedProps(OutLifetimeProps);

// only to local owner: weapon change requests are locally instigated, other clients don't need it
DOREPLIFETIME_CONDITION(ATOCharacter, Inventory, COND_OwnerOnly);



// everyone

DOREPLIFETIME(ATOCharacter, Health);

}

void ATOCharacter::Reset()
{
Health = HealthMax;
DamageInfoArray.Empty();

}

void ATOCharacter::OnRep_CurrentWeapon(AItems* LastWeapon)
{
SetCurrentWeapon(CurrentWeapon, LastWeapon);
}

ETeam_Enum ATOCharacter::GetTeam() const
{
ABasePlayerState * PS = Cast<ABasePlayerState>(PlayerState);
if (PS)
{
return PS->GetTeam();
}

return ETeam_Enum::None;

}

//////////////////////////////////////////////////////////
//Inventory

void ATOCharacter::AddWeapon(AItems* Weapon)
{
if (Weapon && Role == ROLE_Authority)
{
Weapon->OnEnterInventory(this);
Inventory.AddUnique(Weapon);
}
else ServerAddWeapon(Weapon);
}

bool ATOCharacter::ServerAddWeapon_Validate(AItems* Weapon)
{
return true;
}

void ATOCharacter::ServerAddWeapon_Implementation(AItems* Weapon)
{
AddWeapon(Weapon);
}

void ATOCharacter::RemoveWeapon(AItems* Weapon)
{
if (Weapon && Role == ROLE_Authority)
{
Weapon->OnLeaveInventory();
Inventory.RemoveSingle(Weapon);
}
}

void ATOCharacter::SpawnDefaultInventory()
{
if (Role < ROLE_Authority)
{
return;
}

int32 NumWeaponClasses = DefaultInventoryClasses.Num();
for (int32 i = 0; i &lt; NumWeaponClasses; i++)
{
	if (DefaultInventoryClasses*)
	{
		FActorSpawnParameters SpawnInfo;
		SpawnInfo.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
		AItems* NewWeapon = GetWorld()-&gt;SpawnActor&lt;AItems&gt;(DefaultInventoryClasses*, SpawnInfo);
		AddWeapon(NewWeapon);
	}
}

// equip first weapon in inventory
if (Inventory.Num() &gt; 0)
{
	EquipWeapon(Inventory[0]);
}

}

void ATOCharacter::EquipWeapon(AItems* Weapon)
{

if (Weapon)
{
	if (Role == ROLE_Authority)
	{
		SetCurrentWeapon(Weapon, CurrentWeapon);
	}
	else
	{
		ServerEquipWeapon(Weapon);
	}
}

}

bool ATOCharacter::ServerEquipWeapon_Validate(AItems* Weapon)
{
return true;
}

void ATOCharacter::ServerEquipWeapon_Implementation(AItems* Weapon)
{
EquipWeapon(Weapon);
}

void ATOCharacter::DestroyInventory()
{
if (Role < ROLE_Authority)
{
return;
}

// remove all weapons from inventory and destroy them
for (int32 i = Inventory.Num() - 1; i &gt;= 0; i--)
{
	AItems* Weapon = Inventory*;
	if (Weapon)
	{
		RemoveWeapon(Weapon);
		Weapon-&gt;Destroy();
	}
}

}

void ATOCharacter::SetCurrentWeapon(AItems* NewWeapon, AItems* LastWeapon)
{

AItems* LocalLastWeapon = NULL;

if (LastWeapon != NULL)
{
	LocalLastWeapon = LastWeapon;
}
else if (NewWeapon != CurrentWeapon)
{
	LocalLastWeapon = CurrentWeapon;
}

// unequip previous
if (LocalLastWeapon)
{
	LocalLastWeapon-&gt;OnUnEquip();
}

CurrentWeapon = NewWeapon;

// equip new one
if (NewWeapon)
{
	NewWeapon-&gt;SetOwningPawn(this);	// Make sure weapon's MyPawn is pointing back to us. During replication, we can't guarantee APawn::CurrentWeapon will rep after AWeapon::MyPawn!

	NewWeapon-&gt;OnEquip(LastWeapon);
}

}

void ATOCharacter::OnNextWeapon()
{
ABasePlayerController* MyPC = Cast<ABasePlayerController>(Controller);
if (MyPC )
{
if (Inventory.Num() >= 2 && (CurrentWeapon == NULL || CurrentWeapon->GetCurrentState() != EWeaponState::Equipping))
{
const int32 CurrentWeaponIdx = Inventory.IndexOfByKey(CurrentWeapon);
AItems* NextWeapon = Inventory(CurrentWeaponIdx + 1) % Inventory.Num()];
EquipWeapon(NextWeapon);
}
}

}

void ATOCharacter::OnPrevWeapon()
{
ABasePlayerController* MyPC = Cast<ABasePlayerController>(Controller);
if (MyPC )
{
if (Inventory.Num() >= 2 && (CurrentWeapon == NULL || CurrentWeapon->GetCurrentState() != EWeaponState::Equipping))
{
const int32 CurrentWeaponIdx = Inventory.IndexOfByKey(CurrentWeapon);
AItems* PrevWeapon = Inventory(CurrentWeaponIdx - 1 + Inventory.Num()) % Inventory.Num()];

		EquipWeapon(PrevWeapon);
	}
}

}

void ATOCharacter::CanAddItem_Implementation(class AItems* ItemChecked)
{

}
////////////////////////////////////////////////////

const TArray<FDamageInfo> & ATOCharacter::GetDamageInfoArray() const
{
return DamageInfoArray;
}

FName ATOCharacter::GetWeaponAttachPoint() const
{
return WeaponAttachPoint;
}

USkeletalMeshComponent* ATOCharacter::GetSpecifcPawnMesh(bool WantFirstPerson) const
{
return WantFirstPerson == true ? Mesh1P : GetMesh();
}

USkeletalMeshComponent* ATOCharacter::GetPawnMesh() const
{
return IsFirstPerson() ? Mesh1P : GetMesh();
}

bool ATOCharacter::IsFirstPerson() const
{
return IsAlive() && Controller && Controller->IsLocalPlayerController();
}

bool ATOCharacter::IsAlive() const
{
return Health > 0;
}

FRotator ATOCharacter::GetAimOffsets() const
{
const FVector AimDirWS = GetBaseAimRotation().Vector();
const FVector AimDirLS = ActorToWorld().InverseTransformVectorNoScale(AimDirWS);
const FRotator AimRotLS = AimDirLS.Rotation();

return AimRotLS;

}

And the code of my weapon:
// Fill out your copyright notice in the Description page of Project Settings.

#include “TOUnderFire.h”
#include “Items.h”
#include “UnrealNetwork.h”
#include “Player/TOCharacter.h”

// Sets default values
AItems::AItems(const FObjectInitializer & ObjectInitializer)
: Super(ObjectInitializer)
{
ItemMesh = ObjectInitializer.CreateDefaultSubobject<USkeletalMeshComponent>(this, TEXT(“WeaponMesh1P”));
ItemMesh->MeshComponentUpdateFlag = EMeshComponentUpdateFlag::OnlyTickPoseWhenRendered;
ItemMesh->bReceivesDecals = false;
ItemMesh->CastShadow = false;
ItemMesh->SetCollisionObjectType(ECC_WorldDynamic);
ItemMesh->SetCollisionEnabled(ECollisionEnabled::NoCollision);
ItemMesh->SetCollisionResponseToAllChannels(ECR_Ignore);
RootComponent = ItemMesh;

ItemMesh3P = ObjectInitializer.CreateDefaultSubobject&lt;USkeletalMeshComponent&gt;(this, TEXT("WeaponMesh3P"));
ItemMesh3P-&gt;MeshComponentUpdateFlag = EMeshComponentUpdateFlag::OnlyTickPoseWhenRendered;
ItemMesh3P-&gt;bReceivesDecals = false;
ItemMesh3P-&gt;CastShadow = true;
ItemMesh3P-&gt;SetCollisionObjectType(ECC_WorldDynamic);
ItemMesh3P-&gt;SetCollisionEnabled(ECollisionEnabled::NoCollision);
ItemMesh3P-&gt;SetCollisionResponseToAllChannels(ECR_Ignore);
//ItemMesh3P-&gt;SetCollisionResponseToChannel(COLLISION_WEAPON, ECR_Block);
ItemMesh3P-&gt;SetCollisionResponseToChannel(ECC_Visibility, ECR_Block);
//ItemMesh3P-&gt;SetCollisionResponseToChannel(COLLISION_PROJECTILE, ECR_Block);
ItemMesh3P-&gt;SetupAttachment(ItemMesh);

CanbePickUp = false;

ItemSlot = EItemSlotEnum::None; 

// 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;
 ItemName = "";
 CostToPurchase = 0;
 NumMaxItem = 1;

 bIsEquipped = false;
 bPendingReload = false;
 bPendingEquip = false;
 CurrentState = EWeaponState::Idle;

}

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

}

void AItems::Reset()
{
Super::Reset();

}

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

}

void AItems::OnRep_Instigator()
{
Super::OnRep_Instigator();

}

bool AItems::CanBePickedUp() const
{
return !Instigator;
}

bool AItems::CanBeDropped() const
{
return true;
}

void AItems::AttachMeshToPawn()
{
if (MyPawn)
{
// Remove and hide both first and third person meshes
DetachMeshFromPawn();

	// OnATTach remplace provisoirement la suite de ce code, pour pouvoir 
	//l'implementer par blueprint et debugger
	OnAttach();
	

	// For locally controller players we attach both weapons and let the bOnlyOwnerSee, bOwnerNoSee flags deal with visibility.
	/*FName AttachPoint = MyPawn-&gt;GetWeaponAttachPoint();
	if (MyPawn-&gt;IsLocallyControlled() == true)
	{
		USkeletalMeshComponent* PawnMesh1p = MyPawn-&gt;GetSpecifcPawnMesh(true);
		USkeletalMeshComponent* PawnMesh3p = MyPawn-&gt;GetSpecifcPawnMesh(false);
		ItemMesh-&gt;SetHiddenInGame(false);
		ItemMesh3P-&gt;SetHiddenInGame(false);
		ItemMesh-&gt;AttachToComponent(PawnMesh1p, FAttachmentTransformRules::KeepRelativeTransform, AttachPoint);
		ItemMesh3P-&gt;AttachToComponent(PawnMesh3p, FAttachmentTransformRules::KeepRelativeTransform, AttachPoint);
		
	}
	else
	{
		USkeletalMeshComponent* UseWeaponMesh = GetWeaponMesh();
		USkeletalMeshComponent* UsePawnMesh = MyPawn-&gt;GetPawnMesh();
		UseWeaponMesh-&gt;AttachToComponent(UsePawnMesh, FAttachmentTransformRules::KeepRelativeTransform, AttachPoint);
		UseWeaponMesh-&gt;SetHiddenInGame(false);
	}*/
}

}

void AItems::OnAttach_Implementation()
{

}

void AItems::DetachMeshFromPawn()
{
ItemMesh->DetachFromComponent(FDetachmentTransformRules::KeepRelativeTransform);
ItemMesh->SetHiddenInGame(true);

ItemMesh3P-&gt;DetachFromComponent(FDetachmentTransformRules::KeepRelativeTransform);
ItemMesh3P-&gt;SetHiddenInGame(true);

}

USkeletalMeshComponent* AItems::GetWeaponMesh() const
{
return (MyPawn != NULL && MyPawn->IsFirstPerson()) ? ItemMesh : ItemMesh3P;
}

//////////////////////////////////////////////////////////////////////////
// Replication & effects

void AItems::OnRep_MyPawn()
{
if (MyPawn)
{
OnEnterInventory(MyPawn);
}
else
{
OnLeaveInventory();
}
}

void AItems::OnEnterInventory(ATOCharacter* NewOwner)
{
SetOwningPawn(NewOwner);
}

void AItems::OnLeaveInventory()
{
if (Role == ROLE_Authority)
{
SetOwningPawn(NULL);
}

if (IsAttachedToPawn())
{
	OnUnEquip();
}

}

bool AItems::IsAttachedToPawn() const
{
return bIsEquipped || bPendingEquip;
}

void AItems::SetOwningPawn(ATOCharacter* NewOwner)
{
if (MyPawn != NewOwner)
{
Instigator = NewOwner;
MyPawn = NewOwner;
// net owner for RPC calls
SetOwner(NewOwner);
}
}

//////////////////////////////////////////////////////////////////////////
// Inventory

void AItems::OnEquip(const AItems* LastWeapon)
{

 AttachMeshToPawn();

 bPendingEquip = true;
 DetermineWeaponState();

 // Only play animation if last weapon is valid
if (LastWeapon)
 {
	  float Duration = PlayWeaponAnimation(EquipAnim);
	 if (Duration &lt;= 0.0f)
	 {
		 // failsafe
		 Duration = 0.5f;
	 }
	 EquipStartedTime = GetWorld()-&gt;GetTimeSeconds();
	 EquipDuration = Duration;

	 GetWorldTimerManager().SetTimer(TimerHandle_OnEquipFinished, this, &AItems::OnEquipFinished, Duration, false);

}
 else
 {
	 OnEquipFinished();
 }
 
 if (MyPawn && MyPawn-&gt;IsLocallyControlled())
 {
	 PlayWeaponSound(EquipSound);
 }

}

void AItems::OnEquipFinished()
{
AttachMeshToPawn();

 bIsEquipped = true;
 bPendingEquip = false;

 // Determine the state so that the can reload checks will work
 DetermineWeaponState();

}

void AItems::OnUnEquip()
{
DetachMeshFromPawn();
bIsEquipped = false;
/*StopFire();

if (bPendingReload)
{
	StopWeaponAnimation(ReloadAnim);
	bPendingReload = false;

	GetWorldTimerManager().ClearTimer(TimerHandle_StopReload);
	GetWorldTimerManager().ClearTimer(TimerHandle_ReloadWeapon);
}

if (bPendingEquip)
{
	StopWeaponAnimation(EquipAnim);
	bPendingEquip = false;

	GetWorldTimerManager().ClearTimer(TimerHandle_OnEquipFinished);
}

DetermineWeaponState();*/

}

void AItems::GetLifetimeReplicatedProps(TArray< FLifetimeProperty > & OutLifetimeProps) const
{
Super::GetLifetimeReplicatedProps(OutLifetimeProps);

DOREPLIFETIME(AItems, MyPawn);

}

UAudioComponent* AItems::PlayWeaponSound(USoundCue* Sound)
{
UAudioComponent* AC = NULL;
if (Sound && MyPawn)
{
AC = UGameplayStatics::SpawnSoundAttached(Sound, MyPawn->GetRootComponent());
}

return AC;

}

void AItems::DetermineWeaponState()
{
EWeaponState::Type NewState = EWeaponState::Idle;

if (bIsEquipped)
{
	if (bPendingReload)
	{
		if (CanReload() == false)
		{
			NewState = CurrentState;
		}
		else
		{
			NewState = EWeaponState::Reloading;
		}
	}
	else if ((bPendingReload == false) && (bWantsToFire == true) && (CanFire() == true))
	{
		NewState = EWeaponState::Firing;
	}
}
else if (bPendingEquip)
{
	NewState = EWeaponState::Equipping;
}

SetWeaponState(NewState);

}

void AItems::SetWeaponState(EWeaponState::Type NewState)
{
const EWeaponState::Type PrevState = CurrentState;
/*
if (PrevState == EWeaponState::Firing && NewState != EWeaponState::Firing)
{
OnBurstFinished();
}

CurrentState = NewState;

if (PrevState != EWeaponState::Firing && NewState == EWeaponState::Firing)
{
	OnBurstStarted();
}*/

}

EWeaponState::Type AItems::GetCurrentState() const
{
return CurrentState;
}

bool AItems::CanFire() const
{
// return IsAlive();
return true;
}

void AItems::OnRep_Reload()
{
/if (bPendingReload)
{
StartReload(true);
}
else
{
StopReload();
}/
}

bool AItems::CanReload() const
{
return true;
}

float AItems::PlayWeaponAnimation(const FWeaponAnim& Animation)
{
float Duration = 0.0f;
if (MyPawn)
{
UAnimMontage* UseAnim = MyPawn->IsFirstPerson() ? Animation.Pawn1P : Animation.Pawn3P;
if (UseAnim)
{
Duration = MyPawn->PlayAnimMontage(UseAnim);
}
}

return Duration;

}

void AItems::MeshAttash_Implementation()
{

}