1.給物體施加一個徑向力

定義一個徑向力：

URadialForceComponent* RadialForceComp;

在建構函式裡賦預設值：

RadialForceComp = CreateDefaultSubobject<URadialForceComponent>(TEXT("RadialForceComp"));
RadialForceComp->SetupAttachment(MeshComp);
RadialForceComp->Radius = 250.0f; //力影響的半徑範圍
RadialForceComp->bImpulseVelChange = true;//作用力速率變化為真
RadialForceComp->bAutoActivate = false;//prevent component from ticking, and only use fireImpulse() instead把自動啟用關閉，用fireimpulse的方法來代替
RadialForceComp->bIgnoreOwningActor = true;//是否忽略自身

觸發：

RadialForceComp->FireImpulse();

 

 

2.建立一個ActorComponent處理主角掉血事件

新建一個類 繼承自UActorComponent：

class COOPGAME_API USHealthComponent : public UActorComponent

定義一個OnHealthChanged的事件：

UPROPERTY(BlueprintAssignable,Category = "Events")
FOnHealthChangedSignature OnHealthChanged;

在UCLASS的上面宣告這個事件：

DECLARE_DYNAMIC_MULTICAST_DELEGATE_SixParams(FOnHealthChangedSignature, USHealthComponent*, HealthComp, float, Health, float, HealthDelta, const class UDamageType*, DamageType, class AController*, InstigatedBy, AActor*, DamageCauser);//定義一個動態、多播、委託、六個引數的事件

定義一個HandleTakeAnyDamage的事件來處理受到的傷害：

UFUNCTION()
void HandleTakeAnyDamage(AActor* DamagedActor ,float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, AActor* DamageCauser);

將主角受到的傷害動態繫結到HandleTakeAnyDamage上：

AActor* MyOwner = GetOwner();

if (MyOwner)
{
MyOwner->OnTakeAnyDamage.AddDynamic(this, &USHealthComponent::HandleTakeAnyDamage);
}

實現HandleTakeAnyDamage方法：

void USHealthComponent::HandleTakeAnyDamage(AActor * DamagedActor, float Damage, const UDamageType * DamageType, AController * InstigatedBy, AActor * DamageCauser)
{
if (Damage <= 0.0f)
{
return;
}

//update helth clamped
Health = FMath::Clamp(Health - Damage, 0.0f, DefaultHealth);

UE_LOG(LogTemp, Warning, TEXT("Health Changed: %s"),*FString::SanitizeFloat(Health));

OnHealthChanged.Broadcast(this, Health, Damage, DamageType, InstigatedBy, DamageCauser);//將引數廣播給OnHealthChanged
}

 

 

3.若要讓伺服器和客戶端同時表現一樣的效果，需要讓伺服器通知客戶端該做什麼，但程式碼依然在伺服器端執行

將是否爆破的UPROPERTY加上ReplicatedUsing = OnRep_Exploded：

UPROPERTY(ReplicatedUsing = OnRep_Exploded)
bool bExploded;

定義一個事件OnRep_Exploded將上述實現

UFUNCTION()
void OnRep_Exploded();

在血量為0時，同時執行 OnRep_Exploded() 函式，目的是為了讓客戶端表現和伺服器端一樣的狀態：

void ASExplosiveBarrel::OnHealthChanged(USHealthComponent * OwningHealthComp, float Health, float HealthDelta, const UDamageType * DamageType, AController * InstigatedBy, AActor * DamageCauser)
{
if (bExploded)
{
return;
}
if (Health <= 0.0f)
{
bExploded = true;
OnRep_Exploded();
FVector BoostIntensity = FVector::UpVector * ExplosionImpulse;
MeshComp->AddImpulse(BoostIntensity, NAME_None, true);

UGameplayStatics::SpawnEmitterAtLocation(GetWorld(), ExplosionEffect, GetActorLocation());
MeshComp->SetMaterial(0, ExplodedMaterial);
RadialForceComp->FireImpulse();
}
}

void ASExplosiveBarrel::OnRep_Exploded()
{
UGameplayStatics::SpawnEmitterAtLocation(GetWorld(), ExplosionEffect, GetActorLocation());
MeshComp->SetMaterial(0, ExplodedMaterial);
}

接下來記得在生命週期中複製bExploded給客戶端，在cpp中引入標頭檔案#include"Net/UnrealNetwork.h"後即可直接新增GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const 方法，後面的引數可保持不變：

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

DOREPLIFETIME(ASExplosiveBarrel,bExploded);
}

 

4.客戶端伺服器端同步

在建構函式中設定可重複為true：

SetReplicates(true);

定義一個伺服器開火的事件，設定UFUNCTION裡面的內容：

UFUNCTION(Server, Reliable, WithValidation)
void ServerFire();

接著在cpp裡新增伺服器開火函式的_Implementation和_Validate，直接在ServerFire後新增（Validate有時候不需要）：

void ASWeapon::ServerFire_Implementation()
{
Fire();
}

bool ASWeapon::ServerFire_Validate()
{
return true;
}

判斷Role是否在伺服器上：

if (Role < ROLE_Authority) //判斷Role是否在伺服器上
{
ServerFire();                       //Role < ROLE_Authority,說明不在伺服器上，讓Server處理這個開火
}

else{}　　　　　　　　　　//在伺服器上，自己處理開火

 

 

 

 

 

 

原始碼貼：

 1 // Fill out your copyright notice in the Description page of Project Settings.
 2 
 3 #pragma once
 4 
 5 #include "CoreMinimal.h"
 6 #include "GameFramework/Character.h"
 7 #include"Public/SWeapon.h"
 8 #include "SCharacter.generated.h"
 9 
10 class UCameraComponent;
11 class USpringArmComponent;
12 class ASWeapon;
13 class USHealthComponent;
14 
15 UCLASS()
16 class COOPGAME_API ASCharacter : public ACharacter
17 {
18     GENERATED_BODY()
19 
20 public:
21     // Sets default values for this character's properties
22     ASCharacter();
23 
24 protected:
25     // Called when the game starts or when spawned
26     virtual void BeginPlay() override;
27 
28     void MoveForward(float value);
29 
30     void MoveRight(float value);
31 
32     void BeginCrouch();
33 
34     void EndCrouch();
35     UFUNCTION(BlueprintImplementableEvent)
36     void JumpFromAction();
37 
38     UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "Components")
39     UCameraComponent* CameraComp;
40 
41     UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
42     USpringArmComponent* SpringArmComp;
43 
44     UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
45     USHealthComponent* HealthComp;
46 
47     bool bWantsToZoom;
48 
49 
50     UPROPERTY(EditDefaultsOnly, Category = "Player")
51     float ZoomedFOV;
52 
53     UPROPERTY(EditDefaultsOnly, Category = "Player",meta = (ClampMin = 0.1,ClampMax = 100))
54     float ZoomInterpSpeed;
55 
56     /*default FOV set during begin play*/
57     float DefaultFOV;
58 
59     void BeginZoom();
60 
61     void EndZoom();
62 
63     UPROPERTY(Replicated)
64     ASWeapon* CurrentWeapon;
65 
66     UPROPERTY(EditDefaultsOnly,Category = "Player")
67     TSubclassOf<ASWeapon> StarterWeaponClass;
68 
69     UPROPERTY(VisibleDefaultsOnly,Category = "Player")
70     FName WeaponAttachSocketName;
71     void StartFire();
72 
73     void StopFire();
74 
75     UFUNCTION()
76     void OnHealthChanged(USHealthComponent* OwingHealthComp, float Health, float HealthDelta, const class UDamageType* DamageType, class AController* InstigatedBy, AActor* DamageCauser);
77 
78     UPROPERTY(Replicated,BlueprintReadOnly,Category = "Player")
79     bool bDied ;
80 public:    
81     // Called every frame
82     virtual void Tick(float DeltaTime) override;
83 
84     // Called to bind functionality to input
85     virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
86 
87     virtual FVector GetPawnViewLocation() const;
88     
89 };

SCharacter.h

  1 // Fill out your copyright notice in the Description page of Project Settings.
  2 
  3 #include "Public/SCharacter.h"
  4 #include"Camera/CameraComponent.h"
  5 #include"GameFramework/SpringArmComponent.h"
  6 #include"Components/CapsuleComponent.h"
  7 #include"CoopGame/CoopGame.h"
  8 #include"SHealthComponent.h"
  9 #include"GameFramework/PawnMovementComponent.h"
 10 #include"Net/UnrealNetwork.h"
 11 
 12 
 13 // Sets default values
 14 ASCharacter::ASCharacter()
 15 {
 16      // Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
 17     PrimaryActorTick.bCanEverTick = true;
 18 
 19     SpringArmComp = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArmComp"));
 20     SpringArmComp->bUsePawnControlRotation = true;
 21     SpringArmComp->SetupAttachment(RootComponent);
 22 
 23     GetMovementComponent()->GetNavAgentPropertiesRef().bCanCrouch = true;
 24 
 25     GetCapsuleComponent()->SetCollisionResponseToChannel(COLLISION_WEAPON, ECR_Ignore);
 26 
 27     HealthComp = CreateDefaultSubobject<USHealthComponent>(TEXT("HealthComp"));
 28 
 29     CameraComp = CreateDefaultSubobject<UCameraComponent>(TEXT("CameraComp"));
 30     CameraComp->bUsePawnControlRotation = true;
 31     CameraComp->SetupAttachment(SpringArmComp);
 32 
 33     ZoomedFOV = 65.0f;
 34     ZoomInterpSpeed = 20.0f;
 35 
 36     WeaponAttachSocketName = "WeaponSocket";
 37 }
 38 
 39 // Called when the game starts or when spawned
 40 void ASCharacter::BeginPlay()
 41 {
 42     Super::BeginPlay();
 43     
 44     DefaultFOV = CameraComp->FieldOfView;
 45 
 46     HealthComp->OnHealthChanged.AddDynamic(this, &ASCharacter::OnHealthChanged);
 47 
 48     if (Role == ROLE_Authority) 
 49     {
 50 
 51     FActorSpawnParameters SpawnParams;
 52     SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
 53 
 54     CurrentWeapon = GetWorld()->SpawnActor<ASWeapon>(StarterWeaponClass, FVector::ZeroVector, FRotator::ZeroRotator, SpawnParams);
 55     if (CurrentWeapon) 
 56     {
 57         CurrentWeapon->SetOwner(this);
 58         CurrentWeapon->AttachToComponent(GetMesh(), FAttachmentTransformRules::SnapToTargetNotIncludingScale,WeaponAttachSocketName);
 59     }
 60 
 61     }
 62 }
 63 
 64 void ASCharacter::MoveForward(float value)
 65 {
 66     AddMovementInput(GetActorForwardVector()*value);
 67 }
 68 
 69 void ASCharacter::MoveRight(float value)
 70 {
 71     AddMovementInput(GetActorRightVector()*value);
 72 }
 73 
 74 void ASCharacter::BeginCrouch()
 75 {
 76     Crouch();
 77 }
 78 
 79 void ASCharacter::EndCrouch()
 80 {
 81     UnCrouch();
 82 }
 83 
 84 
 85 void ASCharacter::BeginZoom()
 86 {
 87     bWantsToZoom = true;
 88 }
 89 
 90 void ASCharacter::EndZoom()
 91 {
 92     bWantsToZoom = false;
 93 }
 94 
 95 void ASCharacter::StartFire()
 96 {
 97     if (CurrentWeapon) 
 98     {
 99         CurrentWeapon->StartFire();
100     }
101 }
102 
103 void ASCharacter::StopFire()
104 {
105     if (CurrentWeapon) 
106     {
107         CurrentWeapon->StopFire();
108     }
109 }
110 
111 void ASCharacter::OnHealthChanged(USHealthComponent* HealthComp, float Health, float HealthDelta, 
112     const class UDamageType* DamageType, class AController* InstigatedBy, AActor* DamageCauser)
113 {
114     if (Health <= 0.0f && !bDied) 
115     {
116         bDied = true;
117         GetMovementComponent()->StopMovementImmediately();
118         GetCapsuleComponent()->SetCollisionEnabled(ECollisionEnabled::NoCollision);
119 
120         DetachFromControllerPendingDestroy();
121 
122         SetLifeSpan(10.0f);
123     }
124 }
125 
126 // Called every frame
127 void ASCharacter::Tick(float DeltaTime)
128 {
129     Super::Tick(DeltaTime);
130 
131     float TargetFOV = bWantsToZoom ? ZoomedFOV : DefaultFOV;
132 
133     float NewFOV = FMath::FInterpTo(CameraComp->FieldOfView, TargetFOV, DeltaTime, ZoomInterpSpeed);
134     CameraComp->SetFieldOfView(NewFOV);
135 
136 }
137 
138 // Called to bind functionality to input
139 void ASCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
140 {
141     Super::SetupPlayerInputComponent(PlayerInputComponent);
142 
143     PlayerInputComponent->BindAxis("MoveForward", this, &ASCharacter::MoveForward);
144     PlayerInputComponent->BindAxis("MoveRight", this, &ASCharacter::MoveRight);
145 
146     PlayerInputComponent->BindAxis("LookUp", this, &ASCharacter::AddControllerPitchInput);
147     PlayerInputComponent->BindAxis("Turn", this, &ASCharacter::AddControllerYawInput);
148 
149     PlayerInputComponent->BindAction("Crouch", IE_Pressed,this, &ASCharacter::BeginCrouch);
150     PlayerInputComponent->BindAction("Crouch", IE_Released,this, &ASCharacter::EndCrouch);
151 
152     PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &ASCharacter::JumpFromAction);
153 
154     PlayerInputComponent->BindAction("Zoom", IE_Pressed, this, &ASCharacter::BeginZoom);
155     PlayerInputComponent->BindAction("Zoom", IE_Released, this, &ASCharacter::EndZoom);
156 
157     PlayerInputComponent->BindAction("Fire", IE_Pressed, this, &ASCharacter::StartFire);
158     PlayerInputComponent->BindAction("Fire", IE_Released, this, &ASCharacter::StopFire);
159 }
160 
161 FVector ASCharacter::GetPawnViewLocation() const
162 {
163     if (CameraComp) 
164     {
165         return CameraComp->GetComponentLocation();
166     }
167 
168     return FVector();
169 }
170 void ASCharacter::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
171 {
172     Super::GetLifetimeReplicatedProps(OutLifetimeProps);
173 
174     DOREPLIFETIME(ASCharacter, CurrentWeapon);
175     DOREPLIFETIME(ASCharacter, bDied);
176 }

SCharacter.cpp

 1 // Fill out your copyright notice in the Description page of Project Settings.
 2 
 3 #pragma once
 4 
 5 #include "CoreMinimal.h"
 6 #include "GameFramework/Actor.h"
 7 #include "SExplosiveBarrel.generated.h"
 8 
 9 class USHealthComponent;
10 class URadialForceComponent;
11 class UParticleSystem;
12 UCLASS()
13 class COOPGAME_API ASExplosiveBarrel : public AActor
14 {
15     GENERATED_BODY()
16     
17 public:    
18     // Sets default values for this actor's properties
19     ASExplosiveBarrel();
20 
21 protected:
22     // Called when the game starts or when spawned
23     virtual void BeginPlay() override;
24 
25     UPROPERTY(VisibleAnywhere,Category = "Components")
26     USHealthComponent* HealthComp;
27 
28     UPROPERTY(VisibleAnywhere, Category = "Components")
29     UStaticMeshComponent* MeshComp;
30 
31     UPROPERTY(VisibleAnywhere, Category = "Components")
32     URadialForceComponent* RadialForceComp;
33 
34     UFUNCTION()
35         void OnHealthChanged(USHealthComponent* OwningHealthComp, float Health, float HealthDelta, 
36             const class UDamageType* DamageType, class AController* InstigatedBy, AActor* DamageCauser);
37 
38     UPROPERTY(ReplicatedUsing = OnRep_Exploded)
39         bool bExploded;
40 
41     UFUNCTION()
42         void OnRep_Exploded();
43 
44     UPROPERTY(EditDefaultsOnly, Category = "FX")
45         float ExplosionImpulse;
46     UPROPERTY(EditDefaultsOnly, Category = "FX")
47         UParticleSystem* ExplosionEffect;
48     UPROPERTY(EditDefaultsOnly, Category = "FX")
49         UMaterialInterface* ExplodedMaterial;
50 
51 
52 public:    
53 
54 
55     
56     
57 };

SExplosiveBarrel.h

 1 // Fill out your copyright notice in the Description page of Project Settings.
 2 
 3 #include "SExplosiveBarrel.h"
 4 #include"SHealthComponent.h"
 5 #include"Kismet/GameplayStatics.h"
 6 #include"PhysicsEngine/RadialForceComponent.h"
 7 #include"Components/StaticMeshComponent.h"
 8 #include"Net/UnrealNetwork.h"
 9 
10 
11 // Sets default values
12 ASExplosiveBarrel::ASExplosiveBarrel()
13 {
14      // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
15     HealthComp = CreateDefaultSubobject<USHealthComponent>(TEXT("HealthComp"));
16     HealthComp->OnHealthChanged.AddDynamic(this, &ASExplosiveBarrel::OnHealthChanged);
17 
18     MeshComp = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MeshComp"));
19     RootComponent = MeshComp;
20 
21     RadialForceComp = CreateDefaultSubobject<URadialForceComponent>(TEXT("RadialForceComp"));
22     RadialForceComp->SetupAttachment(MeshComp);
23     RadialForceComp->Radius = 250.0f;
24     RadialForceComp->bImpulseVelChange = true;
25     RadialForceComp->bAutoActivate = false;//prevent component from ticking, and only use fireImpulse() instead
26     RadialForceComp->bIgnoreOwningActor = true;//ignore self
27 
28     ExplosionImpulse = 400;
29 
30     SetReplicates(true);
31     SetReplicateMovement(true);
32 
33 }
34 
35 // Called when the game starts or when spawned
36 void ASExplosiveBarrel::BeginPlay()
37 {
38     Super::BeginPlay();
39     
40 }
41 
42 void ASExplosiveBarrel::OnHealthChanged(USHealthComponent * OwningHealthComp, float Health, float HealthDelta, const UDamageType * DamageType, AController * InstigatedBy, AActor * DamageCauser)
43 {
44     if (bExploded) 
45     {
46         return;
47     }
48     if (Health <= 0.0f) 
49     {
50         bExploded = true;
51         OnRep_Exploded();
52         FVector BoostIntensity = FVector::UpVector * ExplosionImpulse;
53         MeshComp->AddImpulse(BoostIntensity, NAME_None, true);
54 
55         UGameplayStatics::SpawnEmitterAtLocation(GetWorld(), ExplosionEffect, GetActorLocation());
56         MeshComp->SetMaterial(0, ExplodedMaterial);
57         RadialForceComp->FireImpulse();
58     }
59 }
60 
61 void ASExplosiveBarrel::OnRep_Exploded()
62 {
63     UGameplayStatics::SpawnEmitterAtLocation(GetWorld(), ExplosionEffect, GetActorLocation());
64     MeshComp->SetMaterial(0, ExplodedMaterial);
65 }
66 
67 void ASExplosiveBarrel::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
68 {
69     Super::GetLifetimeReplicatedProps(OutLifetimeProps);
70 
71     DOREPLIFETIME(ASExplosiveBarrel,bExploded);
72 }

SExplosiveBarrel.cpp

 1 // Fill out your copyright notice in the Description page of Project Settings.
 2 
 3 #pragma once
 4 
 5 #include "CoreMinimal.h"
 6 #include "Components/ActorComponent.h"
 7 #include "SHealthComponent.generated.h"
 8 
 9 //OnHealthChanged event
10 DECLARE_DYNAMIC_MULTICAST_DELEGATE_SixParams(FOnHealthChangedSignature, USHealthComponent*, HealthComp, float, Health, float, HealthDelta, const class UDamageType*, DamageType, class AController*, InstigatedBy, AActor*, DamageCauser);
11 UCLASS( ClassGroup=(COOP), meta=(BlueprintSpawnableComponent))
12 class COOPGAME_API USHealthComponent : public UActorComponent
13 {
14     GENERATED_BODY()
15 
16 public:    
17     // Sets default values for this component's properties
18     USHealthComponent();
19 
20 protected:
21     // Called when the game starts
22     virtual void BeginPlay() override;
23 
24     UPROPERTY(Replicated,BlueprintReadOnly,Category = "HealthComponent")
25     float Health;
26 
27     UPROPERTY(EditAnywhere,BlueprintReadWrite, Category = "HealthComponent")
28     float DefaultHealth;
29 
30     UFUNCTION()
31     void HandleTakeAnyDamage(AActor* DamagedActor ,float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, AActor* DamageCauser);
32 
33 
34 public:    
35 
36     UPROPERTY(BlueprintAssignable,Category = "Events")
37     FOnHealthChangedSignature    OnHealthChanged;
38     
39 };

SHealthComponent.h

 1 // Fill out your copyright notice in the Description page of Project Settings.
 2 
 3 #include "SHealthComponent.h"
 4 #include"Net/UnrealNetwork.h"
 5 
 6 
 7 // Sets default values for this component's properties
 8 USHealthComponent::USHealthComponent()
 9 {
10     DefaultHealth = 100;
11 
12     SetIsReplicated(true);
13 }
14 
15 
16 // Called when the game starts
17 void USHealthComponent::BeginPlay()
18 {
19     Super::BeginPlay();
20 
21     // ...
22     // Only hook if we are server
23     if (GetOwnerRole() == ROLE_Authority) 
24     {
25 
26         AActor* MyOwner = GetOwner();
27 
28         if (MyOwner)
29         {
30             MyOwner->OnTakeAnyDamage.AddDynamic(this, &USHealthComponent::HandleTakeAnyDamage);
31         }
32     }
33 
34 
35     Health = DefaultHealth;
36 }
37 
38 void USHealthComponent::HandleTakeAnyDamage(AActor * DamagedActor, float Damage, const UDamageType * DamageType, AController * InstigatedBy, AActor * DamageCauser)
39 {
40     if (Damage <= 0.0f) 
41     {
42         return;
43     }
44 
45     //update helth clamped
46     Health = FMath::Clamp(Health - Damage, 0.0f, DefaultHealth);
47 
48     UE_LOG(LogTemp, Warning, TEXT("Health Changed: %s"),*FString::SanitizeFloat(Health));
49 
50     OnHealthChanged.Broadcast(this, Health, Damage, DamageType, InstigatedBy, DamageCauser);
51 }
52 void USHealthComponent::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
53 {
54     Super::GetLifetimeReplicatedProps(OutLifetimeProps);
55 
56     DOREPLIFETIME(USHealthComponent, Health);
57 }

SHealthComponent.cpp

  1 // Fill out your copyright notice in the Description page of Project Settings.
  2 
  3 #pragma once
  4 
  5 #include "CoreMinimal.h"
  6 #include "GameFramework/Actor.h"
  7 #include "SWeapon.generated.h"
  8 
  9 class UDamageType;
 10 class UParticleSystem;
 11 
 12 //
 13 USTRUCT()
 14 struct FHitScanTrace
 15 {
 16     GENERATED_BODY()
 17 
 18 public:
 19     UPROPERTY()
 20     TEnumAsByte<EPhysicalSurface> SurfaceType;
 21     UPROPERTY()
 22     FVector_NetQuantize TraceTo;
 23 };
 24 
 25 UCLASS()
 26 class COOPGAME_API ASWeapon : public AActor
 27 {
 28     GENERATED_BODY()
 29     
 30 public:    
 31     // Sets default values for this actor's properties
 32     ASWeapon();
 33 
 34 protected:
 35     // Called when the game starts or when spawned
 36     virtual void BeginPlay() override;
 37 
 38     UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "Components")
 39     USkeletalMeshComponent* MeshComp;
 40 
 41 
 42     void PlayFireEffects(FVector TraceEnd);
 43 
 44     void PlayImpatEffects(EPhysicalSurface SurfaceType, FVector ImpactPoint);
 45 
 46     UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
 47     TSubclassOf<UDamageType> DamageType;
 48 
 49     UPROPERTY(VisibleDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
 50     FName MuzzleSocketName;
 51     UPROPERTY(VisibleDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
 52     FName TracerTargetName;
 53 
 54     UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
 55     UParticleSystem* MuzzleEffect;
 56 
 57     UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
 58     UParticleSystem*DefaultImpactEffect;
 59 
 60     UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
 61     UParticleSystem*FleshImpactEffect;
 62 
 63     UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
 64     UParticleSystem*TraceEffect;
 65 
 66     UPROPERTY(EditDefaultsOnly, Category = "Weapon")
 67     TSubclassOf<UCameraShake> FireCameraShake;
 68 
 69     UPROPERTY(EditDefaultsOnly, Category = "Weapon")
 70     float BaseDamage;
 71 
 72     UFUNCTION(Server, Reliable, WithValidation)
 73     void ServerFire();
 74 
 75     FTimerHandle TimerHandle_TimeBetweenShots;
 76 
 77     float LastFireTime;
 78 
 79     /*RPM- Bullets per minute fired by weapon*/
 80     UPROPERTY(EditDefaultsOnly, Category = "Weapon")
 81     float RateOfFire;
 82 
 83     float TimeBetweenShots;
 84 
 85     UPROPERTY(ReplicatedUsing = OnRep_HitScanTrace)
 86     FHitScanTrace HitScanTrace;
 87 
 88     UFUNCTION()
 89     void OnRep_HitScanTrace();
 90 public:    
 91     // Called every frame
 92     virtual void Tick(float DeltaTime) override;
 93 
 94     UFUNCTION(BlueprintCallable, Category = "Weapon")
 95     virtual void Fire();
 96 
 97 
 98     void StartFire();
 99 
100     void StopFire();
101 
102     
103 };

SWeapon.h

  1 // Fill out your copyright notice in the Description page of Project Settings.
  2 
  3 #include "Public/SWeapon.h"
  4 #include"Components/SkeletalMeshComponent.h"
  5 #include"DrawDebugHelpers.h"
  6 #include"Kismet/GameplayStatics.h"
  7 #include"Particles/ParticleSystem.h"
  8 #include"PhysicalMaterials/PhysicalMaterial.h"
  9 #include"Particles/ParticleSystemComponent.h"
 10 #include"CoopGame.h"
 11 #include"TimerManager.h"
 12 #include"Net/UnrealNetwork.h"
 13 
 14 
 15 static int32 DebugWeaponDrawing = 0;
 16 FAutoConsoleVariableRef CVARDebugWeaponDrawing(
 17     TEXT("COOP.DebugWeapons"),
 18     DebugWeaponDrawing, 
 19     TEXT("Draw Debug Lines for Weapons"), 
 20     ECVF_Cheat);
 21 // Sets default values
 22 ASWeapon::ASWeapon()
 23 {
 24      // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
 25     PrimaryActorTick.bCanEverTick = true;
 26 
 27     MeshComp = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("MeshComp"));
 28     RootComponent = MeshComp;
 29 
 30     MuzzleSocketName = "MuzzleSocket";    
 31     TracerTargetName = "Target";
 32 
 33     BaseDamage = 20.0f;
 34 
 35     RateOfFire = 600;
 36 
 37     SetReplicates(true);
 38 
 39     NetUpdateFrequency = 66.0f;
 40     MinNetUpdateFrequency = 33.0f;
 41 }
 42 
 43 // Called when the game starts or when spawned
 44 void ASWeapon::BeginPlay()
 45 {
 46     Super::BeginPlay();
 47     
 48     TimeBetweenShots = 60 / RateOfFire;
 49 }
 50 
 51 void ASWeapon::Fire()
 52 {
 53     //Trace the World ,form pawn eyes to cross hair location
 54 
 55     if (Role < ROLE_Authority) 
 56     {
 57         ServerFire();
 58     }
 59 
 60     AActor* MyOwner = GetOwner();
 61     if (MyOwner) 
 62     {
 63         FVector EyeLocation;
 64         FRotator EyeRotation;
 65         MyOwner->GetActorEyesViewPoint(EyeLocation, EyeRotation);
 66 
 67         FVector ShotDirection = EyeRotation.Vector();
 68         FVector TraceEnd = EyeLocation + (ShotDirection * 10000);
 69 
 70         FCollisionQueryParams QueryParams;
 71         QueryParams.AddIgnoredActor(MyOwner);
 72         QueryParams.AddIgnoredActor(this);
 73         QueryParams.bTraceComplex = true;
 74         QueryParams.bReturnPhysicalMaterial = true;
 75 
 76         //Particle"Target"parameter
 77         FVector TracerEndPoint = TraceEnd;
 78 
 79         EPhysicalSurface SurfaceType = SurfaceType_Default;
 80 
 81         FHitResult Hit;
 82         if (GetWorld()->LineTraceSingleByChannel(Hit, EyeLocation, TraceEnd, COLLISION_WEAPON,QueryParams))
 83         {
 84             AActor* HitActor = Hit.GetActor();
 85 
 86             EPhysicalSurface SurfaceType = UPhysicalMaterial::DetermineSurfaceType(Hit.PhysMaterial.Get());
 87 
 88             float ActualDamage = BaseDamage;
 89             if (SurfaceType == SURFACE_FLESHVULNERABLE) 
 90             {  
 91                 //UE_LOG(LogTemp, Warning, TEXT(".........................."));
 92                  ActualDamage *= 4.0f;
 93             }
 94 
 95             UGameplayStatics::ApplyPointDamage(HitActor, ActualDamage, ShotDirection, Hit, MyOwner->GetInstigatorController(), this, DamageType);
 96 
 97             PlayImpatEffects(SurfaceType, Hit.ImpactPoint);
 98 
 99             TracerEndPoint = Hit.ImpactPoint;
100 
101             HitScanTrace.SurfaceType = SurfaceType;
102         }
103         if (DebugWeaponDrawing > 0)
104         {
105             DrawDebugLine(GetWorld(), EyeLocation, TraceEnd, FColor::White, false, 1.0f, 0, 1.0f);
106         }
107         PlayFireEffects(TracerEndPoint);
108 
109         if (Role == ROLE_Authority) 
110         {
111             HitScanTrace.TraceTo = TracerEndPoint;
112 
113         }
114     
115         LastFireTime = GetWorld()->TimeSeconds;
116     }
117 }
118 
119 void ASWeapon::StartFire()
120 {
121     float FirstDelay =FMath::Max(LastFireTime + TimeBetweenShots - GetWorld()->TimeSeconds,0.0f);
122 
123     GetWorldTimerManager().SetTimer(TimerHandle_TimeBetweenShots,this,&ASWeapon::Fire, TimeBetweenShots, true, FirstDelay);
124 
125 }
126 
127 void ASWeapon::StopFire()
128 {
129     GetWorldTimerManager().ClearTimer(TimerHandle_TimeBetweenShots);
130 }
131 
132 void ASWeapon::PlayFireEffects(FVector TraceEnd)
133 {
134     if (MuzzleEffect)
135     {
136         UGameplayStatics::SpawnEmitterAttached(MuzzleEffect, MeshComp, MuzzleSocketName);
137     }
138 
139     if (TraceEffect)
140     {
141         FVector MuzzleLocation = MeshComp->GetSocketLocation(MuzzleSocketName);
142 
143         UParticleSystemComponent* TracerComp = UGameplayStatics::SpawnEmitterAtLocation(GetWorld(), TraceEffect, MuzzleLocation);
144 
145         if (TracerComp)
146         {
147             TracerComp->SetVectorParameter("Target", TraceEnd);
148         }
149     }
150 
151     APawn* MyOwner = Cast<APawn>(GetOwner());
152 
153     if (MyOwner) 
154     {
155         APlayerController* PC = Cast<APlayerController>(MyOwner->GetController());
156         if (PC) 
157         {
158             PC->ClientPlayCameraShake(FireCameraShake);
159         }
160 
161     }
162 }
163 
164 void ASWeapon::PlayImpatEffects(EPhysicalSurface SurfaceType,FVector ImpactPoint)
165 {
166     UParticleSystem* SelectedEffect = nullptr;
167     switch (SurfaceType)
168     {
169     case  SURFACE_FLESHDEFAULT:
170     case  SURFACE_FLESHVULNERABLE:
171         SelectedEffect = FleshImpactEffect;
172         break;
173     default:
174         SelectedEffect = DefaultImpactEffect;
175         break;
176     }
177     if (SelectedEffect)
178     {
179         FVector MuzzleLocation = MeshComp->GetSocketLocation(MuzzleSocketName);
180         FVector ShotDirection = ImpactPoint - MuzzleLocation;
181         ShotDirection.Normalize();
182         UGameplayStatics::SpawnEmitterAtLocation(GetWorld(), SelectedEffect, ImpactPoint, ShotDirection.Rotation());
183 
184     }
185 
186 }
187 
188 void ASWeapon::ServerFire_Implementation()
189 {
190     Fire();
191 }
192 
193 bool ASWeapon::ServerFire_Validate()
194 {
195     return true;
196 }
197 
198 void ASWeapon::OnRep_HitScanTrace()
199 {
200     //play cosmetic FX
201     PlayFireEffects(HitScanTrace.TraceTo);
202     PlayImpatEffects(HitScanTrace.SurfaceType, HitScanTrace.TraceTo);
203 }
204 
205 // Called every frame
206 void ASWeapon::Tick(float DeltaTime)
207 {
208     Super::Tick(DeltaTime);
209 
210 }
211 
212 void ASWeapon::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
213 {
214     Super::GetLifetimeReplicatedProps(OutLifetimeProps);
215 
216     DOREPLIFETIME_CONDITION(ASWeapon, HitScanTrace,COND_SkipOwner);
217 }

SWeapon.cpp

 1 // Fill out your copyright notice in the Description page of Project Settings.
 2 
 3 #pragma once
 4 
 5 #include "CoreMinimal.h"
 6 
 7 #define SURFACE_FLESHDEFAULT        SurfaceType1
 8 #define SURFACE_FLESHVULNERABLE        SurfaceType2
 9 
10 #define COLLISION_WEAPON            ECC_GameTraceChannel1

CoopGame.h

1 // Fill out your copyright notice in the Description page of Project Settings.
2 
3 #include "CoopGame.h"
4 #include "Modules/ModuleManager.h"
5 
6 IMPLEMENT_PRIMARY_GAME_MODULE( FDefaultGameModuleImpl, CoopGame, "CoopGame" );

CoopGame.cpp

 1 // Fill out your copyright notice in the Description page of Project Settings.
 2 
 3 #pragma once
 4 
 5 #include "CoreMinimal.h"
 6 #include "SWeapon.h"
 7 #include "SProjectileWeapon.generated.h"
 8 
 9 /**
10  * 
11  */
12 UCLASS()
13 class COOPGAME_API ASProjectileWeapon : public ASWeapon
 
 

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
UE4 多人網路對戰遊戲筆記
     
 1.給物體施加一個徑向力 
定義一個徑向力： 
URadialForceComponent* RadialForceComp; 
在建構函式裡賦預設值： 
RadialForceComp = CreateDefaultSubobject<URadialForceComponent>(TEXT("R 

  
 

    

    
    
Java swing + socket 寫的一個五子棋網路對戰遊戲
     
 
							
							
							##網路對戰版本的五子棋遊戲，包含服務端和客戶端(c/s模式) ，寫成此文章給需要或想研究的人一些參考(相關程式碼我會放在本文的最後)
遊戲效果圖：

###下載線上客戶端版本試玩：
（插播：下面連結下載的客戶端如果登入不了伺服器的話，請直接下載文章最後的程式碼 

  
 

    

    
    
從零學習遊戲伺服器開發（一） 從一款多人聯機實時對戰遊戲開始
     
 
                寫在前面的話      經常有學生或者初學者問我如何去閱讀和學習一個開源軟體的程式碼，也有不少朋友在工作崗位時面對前同事留下的專案，由於文件不完善、程式碼註釋少、工程數量大，而無從下手。本文將來通過一個多人聯機實時對戰遊戲——最後一戰，來解答以上問題。      其實，我以上 

  
 

    

    
    
java多執行緒系列：通過對戰遊戲學習CyclicBarrier
     
 
                    

CyclicBarrier是java.util.concurrent包下面的一個工具類，字面意思是可迴圈使用（Cyclic）的屏障（Barrier），通過它可以實現讓一組執行緒到達一個屏障（也可以叫同步點）時被阻塞，直到最後一個執行緒到達屏障時，所有被屏障攔截的執 

  
 

    

    
    
c#對戰遊戲
     
 con   勝利   put   效果   amp   else   true   return   gree   namespace 對戰遊戲{       class Program    {        public struct ZhanShi        {            public  

  
 

    

    
    
Java NIO示例：多人網路聊天室
     
 
                



一個多客戶端聊天室，支援多客戶端聊天，有如下功能：

功能1： 客戶端通過Java NIO連線到服務端，支援多客戶端的連線
	功能2：客戶端初次連線時，服務端提示輸入暱稱，如果暱稱已經有人使用，提示重新輸入，如果暱稱唯一，則登入成功，之後傳送訊息都需要按照規定格式帶著 

  
 

    

    
    
簡單對戰遊戲Java版源程式
     
 
							
							
							簡單對戰遊戲Java版

紅警大戰Java簡單版僅供大家交流使用，有用的請點個贊或者留個言，沒用的也不要踩啊，謝謝！！！

專案結構如下： 


GameTest類



import java.util.Scanner;

public class GameT 

  
 

    

    
    
約嗎？EOS上的首款多人聯機大富翁遊戲-PandaFun來了！
     
 
							
							
							

DAppWorld——最全最新的區塊鏈應用平臺，同時還提供好玩遊戲的評測和攻略，歡迎訪問 

今天DAppWorld小編要介紹的遊戲是PandaFun，一款由國內團隊在EOS上開發的遊戲。

說起EOS不由得記起2018年6月10日EOS主網上線當晚，DAp 

  
 

    

    
    
websocket入門（2）——使用socket.io實現網路對戰版五子棋
     
 
							
							
							





五子棋網路對戰版說明

1、安裝與執行

請完整的down下除了node_modules資料夾以外的所有檔案，然後在控制檯執行 npm install來進行安裝。

安裝完畢後，通過 npm start 命令來執行伺服器，然後通過 127.0.0.1 

  
 

    

    
    
用java類和物件寫一個簡單的回合制對戰遊戲
     
 
                一、什麼是物件，什麼是類類比現實生活，任何一個具體的事物都可以稱為物件，比如某臺電腦，某本書，某個人……而類就是根據物件相似的特徵和功能進行分類，物件是具體的，類是抽象的。二、類的基本格式public class 類名 {//定義屬性訪問修飾符  資料型別  屬性名;//定義 

  
 

    

    
    
實時對戰遊戲PVP開發之PUN使用中常見問題總結
     
 
                PUN在使用過程中常遇到的問題和疑問，本篇文章可以幫你解決PUN使用和選擇的疑問，順利完成PVP實時對戰遊戲開發。哪款Photon產品適合我？這是一個難以回答的問題，因為它取決於你正在製作的遊戲和你的專案的具體情況。 不過，可以推薦以下內容幫你進行選擇：如果您仍然有疑問，請隨 

  
 

    

    
    
使用Qt開發中國象棋（七）：網路對戰
     
 
							
							
							關於Qt網路程式設計

QTcpServer用於建立TCP伺服器端。當newConnection訊號激發時，我們呼叫指定的槽建立一個通訊的套接字。 
QTcpSocket用於建立TCP通訊套接字。當connected訊號激發時，我們向伺服器端傳送訊息，當read 

  
 

    

    
    
Unity中國象棋（五）——網路對戰的實現（服務端的基本功能）
     
 
                
博主主要是用了socket的方法去實現了伺服器和客戶端之間的通訊，由於樓主對於socket網路程式設計這一方面的基礎相當薄弱，故也是邊學邊學，有些地方的程式碼不夠完善還請大神指正！博主還需學習。

首先，先說說服務端方面：服務端採用的是VS的windows form窗體應用 

  
 

    

    
    
Unity+ Photon伺服器實時對戰遊戲——主伺服器和大廳（四）
     
 
                
Master Server And Lobby 主伺服器和大廳
PUN always uses a master server and one or more game servers. The master server manages currently running 

  
 

    

    
    
HTML5遊戲開發進階 11：WebSocket與多人對戰模式
     
 
                
    我們將使用HTML5 WebSocket API向我們的RTS遊戲加入多人對戰支援
11.1 使用Node.js操作WebSocket API
   之前瀏覽器與伺服器之間通訊的唯一方式就是通過逐個request序列，對伺服器進行輪詢或長輪詢。雖然這些方式確實有效， 

  
 

    

    
    
多人即時戰鬥遊戲服務端系列[2]--90坦克Online遊戲對象介紹以及渲染機制
     
 d+   ica   部分   avi   產生   4.4   1.8   timer   lock   

先上類圖,略大,點擊此處放大:




1.先說下方接口
  1.1 場景物品接口 ISceneObject : OpLog.IOpItem, IStackPoolObject

全部場景對象的基本 

  
 

    

    
    
（轉整）UE4遊戲優化  多人大地型遊戲的優化（一）遊戲線程的優化
     
 兼容   source   bubuko   又是   mic   ini   策略   動態   author      
   
   
施主分享隨緣，評論隨心，@author:白袍小道
   
小道暗語：
1、因為小道這裏博客目錄沒自己整，暫時就用隨筆目錄結構，所以二級目錄那啥就忽略了。標題格式大致都是 

  
 

    

    
    
2018TGDC王禰：UE4製作多人大地型遊戲的優化
     
  
 
 在2018TGDC大會上，來自Epic Games中國資深技術工程師王禰先生髮表了《UE4製作多人大地型遊戲的優化》主題演講。王禰有近10年的虛幻引擎使用經驗，從console遊戲、掌機到PC端MMO遊戲，再到手遊，都有過相關開發經驗；現在Epic Games China，他作為唯一的引擎技術專家， 

  
 

    

    
    
MTGAN:通過多工三元生成對抗性網路對說話人進行驗證
     
  
 
 MTGAN: Speaker Verification through Multitasking Triplet Generative Adversarial Networks 
 MTGAN:通過多工三元生成對抗性網路對說話人進行驗證 
 摘要 
 在本文中，我們提出了一種增強的三元組方法，它通過 

  
 

    

    
    
基於Android平臺的網路遊戲對戰系統專案可執行程式及原始碼
     
 
                
     這是一個基於Java Socket程式設計的網路應用程式，既然是基於網路應用那麼必然包含客戶端程式以及伺服器端程式兩部分。簡要介紹一下專案的設計：
    1.伺服器方面：
            1）要進行網路程式設計，必須開發伺服器端程式，但是開發之前有一些準