UE4的编程C++建立一个FPSproject（两）角色网格、动画、HUD、子弹类

时间  2019-11-30
标签 ue4 编程 c++ 建立 一个 fpsproject 角色 网格 动画 hud 子弹 栏目 C&C++ 繁體版
原文   原文链接

    当即归还，本文将总结全部这些整理UE4有关角色的网络格、动画、子弹类HUD一个简单的实现。数组

（五）角色加入网格
浏览器

  Character类为咱们默认建立了一个SkeletaMeshComponent组件，因此咱们只需要作的就是使用哪个静态网格模型。接下来咱们为咱们的FPSCharacter类建立一个蓝图，这样咱们可以简单的把资源指定给静态网格模型这里，并且方便之后操做加入的组件。网络

做为開始，咱们首先要导入一个第三人称的静态网格模型。最后咱们设置成两个网格，一个是咱们本身看的，另一个是其它人看到的。ssh


 1.加入一个完整的全身的网格。现在点击这里加载资源吧。编辑器

我把咱们要用到的全部资源全部放进去了，GenericMale.fbx文件就是有全身网格的，HeroFPP.FBX是等下咱们要用到的本身看本身仅仅有胳膊和武器的网格，Sphere.FBX是个球体网格模拟子弹，crosshair.TGA是瞄准的十字准心。FPP_Animations文件夹存放的是胳膊和武器的那个网格的用的的动画。这是个人文件夹结构，仅供參考。函数

  

   你们把他们都加载进来吧，注意一点就是，注意加载全部。比方加载网格，需要勾选加载材质，加载动做的时候。要选择网格，例如如下：oop

  

        好了。关于资源加载的问题，就一次性说清，之后就不说了。学习

      2.在蓝图目录内，新建蓝图动画

        

  

  这里注意。在下拉框中选择FPSCharacter，使其做为蓝图的父类，给蓝图命名为“BP_FPSCharacter”，打开它。
this

  3.选中Mesh。指定网格，并把Mesh的z轴值改成-88

   


  完毕之后就应该是这样了。为何是-88？因为是已经调整好的数值，当使用本身的网格模型时。需要本身调整。终于目标是 使得网格被外面的胶囊组件包裹，并且方向为箭头所指向的方向。这将会使得模型在世界中正确行走，方向正常。可以直接在视图中调整，也可以直接设置数值。

 4.编译保存蓝图，现在，咱们要告诉咱们的游戏模型使用最新咱们建立的蓝图类来做为游戏角色的pawn物体。而不是咱们以前建立的父类：FPSCharacter。返回VS,在模式的CPP文件构造函数中，删除

DefaultPawnClass = AFPSCharacter::StaticClass();
  并加入例如如下代码： 

AMyNewFPSGameMode::AMyNewFPSGameMode(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	//DefaultPawnClass = AMyNewFPSCharacter::StaticClass();

	static ConstructorHelpers::FObjectFinder<UBlueprint> PlayerPawnObject(TEXT("Blueprint'/Game/Blueprints/BP_FPSCharacter.BP_FPSCharacter'"));
	if (PlayerPawnObject.Object != NULL)
	{
		DefaultPawnClass = (UClass*)PlayerPawnObject.Object->GeneratedClass;
	}
}
  （这里提早说一下，你们无视个人类名，依照本身的来就能够）
   这里有很重要的一个知识点：在C++中引用蓝图（这样。就可以打通C++和蓝图了！

）。更准确的说应该是引用资源。这里的蓝图是以资源出现，等下咱们也会发现在引用十字瞄准点的时候，使  用的是相同的方法，那就是： 

static ConstructorHelpers::FObjectFinder<UBlueprint> PlayerPawnObject(TEXT("Blueprint'/Game/Blueprints/BP_FPSCharacter.BP_FPSCharacter'"));
  TEXT里面的是资源的路径。获取资源路径有个小技巧，就是在内容浏览器中右键资源，选中复制引用命令，就会把详细的位置拷贝到剪贴板中了。

  5.回到编辑器。选择编译，等待编译成功进入游戏測试。假设你移动摄像机。你会发现角色的影子，按下F1+Shift键，来得到鼠标指针。点击上面的弹出。这  时候就可以在世界中任意的移动摄像机来看到角色的网格。

（六）更改摄像机试图（加入摄像机组件）

     在上一节的结尾。默认的摄像机是在网格的脖子里，现在咱们来建立一个正确的摄像机。并且可以设置摄像机的一些属性比方位置和视图。咱们经过给咱们的FPSCharacter类加入一个摄像机组件来完毕（CameraComponent ）。首先。咱们为FPSCharacter加入一个属性来引用摄像机组件。

   1.在角色.h文件中面加入如下的代码来加入一个公有变量FirstPersonCameraComponent。

/** First person camera
	* 为摄像机新建变量，引用摄像机。在构造函数中作初始化------C++中加入组件。。蓝图中赋值。
	*/
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera)
		TSubobjectPtr<UCameraComponent> FirstPersonCameraComponent;
  2.咱们在FPSCharacter的构造函数中建立真正的组件，在FPSCharacter的构造函数中加入例如如下代码，来建立一个摄像机组件并且把他依附到胶囊组件上。

AMyNewFPSCharacter::AMyNewFPSCharacter(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	/********************建立、初始化摄像机********************************/
	//建立摄像机组件
	FirstPersonCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
	FirstPersonCameraComponent->AttachParent = CapsuleComponent;

	// 摄像机的位置略微比眼睛要高
	FirstPersonCameraComponent->RelativeLocation = FVector(0, 0, 50.0f + BaseEyeHeight);
	// 赞成玩家控制旋转
	FirstPersonCameraComponent->bUsePawnControlRotation = true;
}

  3.咱们来调整摄像机的位置到眼睛的位置,在蓝图中也可以做调整，这里仅仅用调整他的位置信息，不用调整旋转。因为旋转会被鼠标改变。这部分代码就是上面的下两行。

  4.好了。进游戏測试吧，摄像机应该在角色的头上，因此当你向下看的时候。将会看到角色的头部。

（七）加入第一人称网格

   常规的FPS要准备和处理两套网格，一套是其它人看到的本身，但是对于本身来讲它是隐藏的。这个就是全身的网格；另外一种是仅仅有武器和手臂的网格，他们要依附在摄像机上。当玩家是第一人称的时候才被看到。

为了实现这个。咱们首先要保持现有的网格，给它命名为“Mesh”。并且为咱们的第一人称网格准备一个新的静态网格模型。

  1.角色的.h文件里新建变量来引用新的网格。

/**
	* 出生的时候的网格，仅仅有手臂和武器。 也是加入一个变量引用新的网格
	*/
	UPROPERTY(VisibleDefaultsOnly, Category = Mesh)
		TSubobjectPtr<USkeletalMeshComponent> FirstPersonMesh;
 2.在构造函数中。加入例如如下代码来建立配置网格

///********************建立、初始化仅仅有手和武器的网格********************************/
	//// 建立一个网格组件。他仅仅有手臂和武器
	FirstPersonMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FirstPersonMesh"));
	FirstPersonMesh->SetOnlyOwnerSee(true);// 仅仅仅仅有这个Pawn才干够看到
	FirstPersonMesh->AttachParent = FirstPersonCameraComponent;
	FirstPersonMesh->bCastDynamicShadow = false;
	FirstPersonMesh->CastShadow = false;


	///********************除了本身。其它人看到全身*******************************/
	//// 除了本身其它人都能看到
	Mesh->SetOwnerNoSee(true);
  上面其一部分代码中。说明了只惟独这个Pawn才干够看到。依附到第一人称摄像机，取消阴影；后一部分代码实现的功能呢，看凝视把。

 3.编译C++代码。打开BP_FPSCharacter 蓝图，选择FirstPersonMesh组件。右面Detail面板中指定。

调整其位置属性为：{240,0,35}，旋转属性{-180, 50, -180}.最后应该获得这么一张图

  

  OK,进入游戏測试吧，

    

   F1+Shift 并且选择弹出鼠标,这是你就不会再占有角色了,这个时候,你可以任意走动,并且看到两我的称的网格.

   

（八）加入弹药。实现射击

   既然已经建立了角色，那咱们给角色实现一个简单的武器，一枚简单的长得很是像手榴弹的子弹将会从屏幕中心射出，直到他碰到世界里面的物体。才会停下来。

接下来咱们便加入输入的事件，事件映射，并且为子弹建立一个新的类。

  1.处理输入。这里就不赘述，简述例如如下：加入事件映射。Fire，鼠标左键。

  2.加入子弹类，使用UE4的C++类向导。相同简述：父类为Actor，命名FPSProjectile。

     3.首先。咱们应该肯定一个简化表示用于碰撞模拟的物理对象。在这里，咱们加入一个球体组件USphereComponent，在.h文件中面定义变量：

/** 胶囊碰撞组件 */
	UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
		TSubobjectPtr<USphereComponent> CollisionComp;
  4.在CPP的构造函数里面加入组件，咱们将把他做为根组件，因为咱们要模拟它，并且在蓝图里面稍后为他加入可视化组件。

AFPSProjectile::AFPSProjectile(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	// 使用球体表明子弹
	CollisionComp = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComp"));
	CollisionComp->InitSphereRadius(15.0f);
	RootComponent = CollisionComp;	
}
 这里是第二次在C++里面直接加入组件了。总结一下过程就是：声明变量--加入组件！

 5.UE4里面有一个自带的组件叫作子弹移动组件ProjectileMovementComponent ，他可以用于简单的弹道式的移动，咱们把它加入到子弹类里面。

  （1）在.h里面加入变量

/**子弹移动组件 */
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Movement)
		TSubobjectPtr<class UProjectileMovementComponent> ProjectileMovement;
  （2）.cpp构造函数里面加入

// 使用子弹移动组件ProjectileMovementComponent控制子弹
	ProjectileMovement = CreateDefaultSubobject<UProjectileMovementComponent>(TEXT("ProjectileComp"));
	ProjectileMovement->UpdatedComponent = CollisionComp;
	ProjectileMovement->InitialSpeed = 3000.f;
	ProjectileMovement->MaxSpeed = 3000.f;
	ProjectileMovement->bRotationFollowsVelocity = true;
	ProjectileMovement->bShouldBounce = true;
	ProjectileMovement->Bounciness = 0.3f;
 6.日后想想，咱们还需要一个功能经过初速度设置来“启动”咱们的弹丸。咱们本身定义一个函数来处理他。首先.h里面声明一个公有函数：

/** 子弹初速度*/
	void InitVelocity(const FVector& ShootDirection);
  cpp里面加入实现函数

void AFPSProjectile::InitVelocity(const FVector& ShootDirection)
{
	if (ProjectileMovement)
	{
		// set the projectile's velocity to the desired direction 在所需方向上设置子弹的速度
		ProjectileMovement->Velocity = ShootDirection * ProjectileMovement->InitialSpeed;
	}
}
 7.既然速度已经制定了，接下来咱们仅仅需要设置一个启动的方向。首先在角色类中加入函数处理输入：

  .h：

void OnFire();
  .cpp文件里加入实现函数，在实现这个函数的时候，有两点需要考虑：

   （1）在哪里产生子弹

   （2）产生什么样的子弹（即传入子弹的类）。

  第一个问题。为了制定产生的位置，咱们需要一个摄像机空间的偏移量做为可以编辑的參数，所以咱们可以在角色蓝图BP_FPSCharacter 里面设置它，而后就可以依据这个数据来计算子弹的初始化速度。主要是第二个，这里也是一个重点，简单来讲，它的实质是两个C++的类是什么样的关系，怎样通讯！咱们解决的办法是，在C++里面定义一个共同拥有变量，而后等下再蓝图里面指定它。

因此在.h里面加入这个共同拥有变量把~

  角色.h  

/***************************这两项要在蓝图里指定******************************************/
	/** 需要实例化的子弹类 */
	UPROPERTY(EditDefaultsOnly, Category = Projectile)
		TSubclassOf<class AFPSProjectile> ProjectileClass;

	/** Gun muzzle's offset from the camera location
	枪口到摄像机的位置偏移量*/
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gameplay)
		FVector MuzzleOffset;
  解释一下变量前面的两个宏，里咱们使用仅仅能在蓝图设置默认EditDefaultsOnly 的说明符,这就意味着你仅仅能在蓝图类里面设置子弹类为默认,而在不是蓝图的每一个实例中. 

  OnFire将会包括下面几步:

  • 因为咱们的子弹产生位置是由相机空间决定,因此在咱们真正计算子弹位置以前需要查询摄像机的位置信息.
  • 尝试实例化子弹.
  • 使用咱们定义的函数给子弹一个初始化的速度.

  OK，最后就是这个函数的实现了。

void AMyNewFPSCharacter::OnFire()
{
	// try and fire a projectile
	if(ProjectileClass !=NULL)
	{
		// Get the camera transform
	FVector CameraLoc;
	FRotator CameraRot;
	GetActorEyesViewPoint(CameraLoc, CameraRot);
	
	// MuzzleOffset is in camera space, so transform it to world space before offsetting from the camera to find the final muzzle position
	FVector const MuzzleLocation = CameraLoc + FTransform(CameraRot).TransformVector(MuzzleOffset);
	FRotator MuzzleRotation = CameraRot;
	MuzzleRotation.Pitch += 10.0f;// skew the aim upwards a bit

	UWorld*const World = GetWorld(); 
	if (World)
	{
		FActorSpawnParameters SpawnParams;
		SpawnParams.Owner = this;
		SpawnParams.Instigator = Instigator;// spawn the projectile at the muzzle
		AFPSProjectile*const Projectile = World->SpawnActor<AFPSProjectile>(ProjectileClass, MuzzleLocation, MuzzleRotation, SpawnParams);

		if (Projectile)
		{
			// find launch direction
			FVector const LaunchDir = MuzzleRotation.Vector();
			Projectile->InitVelocity(LaunchDir);
		}
	}
}
}
  这个函数有点复杂，得需要好好理解一下。最后注意在角色cpp里面加入头文件

#include "FPSProjectile.h"
  8.编译代码，回到编辑器，最后一步为子弹建立蓝图加入网格，建立新的蓝图。父类FPSProjectile。蓝图命名BP_FPSProjectile。在蓝图里面手动加入静态网格组件。命名ProjectileMesh，在右面的Detail面板中指定Mesh值，并调整其大小为：0.09（x、y、z都是）。另外把子弹网格组件ProjectileMesh的碰撞关闭，因为咱们使用球形碰撞体来检測碰撞而不是网格物体。

  

  9.接下来。咱们就要为刚刚C++里面加入的两个共同拥有变量赋值了！打开角色蓝图，点击头上的ClassDefault，而后在右面。你就可以看到这两个变量了。


  分别依照上面赋值！以后，进入游戏測试吧！

应该可是打出子弹了。

（九）设置子弹的碰撞和生命周期

  现在。咱们需要考虑两件事情

  • 咱们打出的子弹现在是不会消失的。 Scene Outliner面板告诉了咱们
  • 弹不会产生碰撞。
  第一件事。幸运的是，UE4所有的Actors都有一个生命的限制。被一个默认生命期限限制。因此在子弹的构造函数中加入例如如下代码控制生命，也可以在蓝图的default中手动加入。   
// 子弹生命周期（所有的Actor都有的參数）
	InitialLifeSpan = 3.0f;
     接下来。就要解决子弹的碰撞问题了。

这部分问题，我看到的材料有点复杂，理解的不是很是透彻。得多操做几遍才干熟悉，我会把英文原文附上。因此熟能生巧...

   1.UE4有几个实用的碰撞渠道，而且还提供了一些咱们可以定制的碰撞渠道，现在咱们来自定义为弹丸碰撞渠道。这样场景中的一切都可以选择怎样在咱们的游戏中和一个子弹的相互做用。

   在引擎配置.ini（ DefaultEngine.ini，位于FPSProject > Config）的下方加入如下的代码：

 [/Script/Engine.CollisionProfile]
   +DefaultChannelResponses=(Channel=ECC_GameTraceChannel1, Name=Projectile)
  这其实是重命名了通用的渠道为“Projectile”。咱们要在本地代码中重命名它，来保证事情的持续性和可读性。

这其实是重命名了通用的渠道为“Projectile”。咱们要在本地代码中重命名它。来保证事情的持续性和可读性。

  2.UE4也有一个功能叫作碰撞分布，实质上是引擎整体使用的预先捆绑的碰撞的设置。日后想一下，也许咱们可以在咱们的游戏有很是多类型的弹丸，假设保持一致的碰撞设置当中多是easy出错的，因此咱们定义为弹一个新的文件。

      继续在DefaultEngine.ini,加入代码：

  +Profiles=(Name="Projectile", CollisionEnabled=QueryOnly,ObjectTypeName=Projectile, CustomResponses=( \
   (Channel=Static,            Response=ECR_Block), \
   (Channel=PawnMovement,      Response=ECR_Block), \
   (Channel=Dynamic,           Response=ECR_Block), \
   (Channel=PhysicsBody,       Response=ECR_Block), \
   (Channel=VehicleMovement,   Response=ECR_Block), \
   (Channel=Destructible,      Response=ECR_Block) \
   ))
  This profile means that the projectile will be blocked by Static Actors, Pawns, Dynamic Actors, Actors simulating Physics, Vehicles, and Destructible Actors. 这个分布意味着，子弹可以被静态物体，Pawns, Dynamic Actors, Actors simulating Physics, Vehicles, and Destructible Actors等等这些物体阻挡。

 3.现在咱们来设置咱们的子弹使用这个分布，在子弹构造函数中，加入如下代码：

	//使用本身定义的碰撞分布
	CollisionComp->BodyInstance.SetCollisionProfileName("Projectile");
  ok，编译一下代码吧。

（十）子弹和世界的物体交互

 既然咱们已经可以发现咱们子弹的碰撞相互做用，咱们可以决定怎么对她作出反应。在咱们的子弹碰撞设置中，咱们已经设置了对块的相互碰撞，接下来咱们要为子弹类加入一个叫作OnHit的函数来处理这些事件。

  1.本身定义一个函数OnHit。在子弹的.h文件下加入声明

/** 当子弹碰到其它物体时被调用*/
	UFUNCTION()  //这个必须有
	void OnHit(class AActor* OtherActor, class UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit);
  2.cpp里面实现它

void AFPSProjectile::OnHit(AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit)
{
	if (OtherActor && (OtherActor != this) && OtherComp)
	{
		OtherComp->AddImpulseAtLocation(ProjectileMovement->Velocity * 100.0f, Hit.ImpactPoint);
	}
}
 3.托付，现在咱们需要把这个函数交给子弹的球形组件的OnComponentBeginOverlap 事件托付，因此在子弹的构造函数中继续加入如下代码：

CollisionComp->OnComponentHit.AddDynamic(this, &AFPSProjectile::OnHit);
 最后，你的子弹构造函数应该是这个样子：

AFPSProjectile::AFPSProjectile(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	// 使用球体表明子弹
	CollisionComp = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComp"));
	CollisionComp->InitSphereRadius(15.0f);
	RootComponent = CollisionComp;
	//使用本身定义的碰撞分布
	CollisionComp->BodyInstance.SetCollisionProfileName("Projectile");
	//碰撞事件托付
	CollisionComp->OnComponentHit.AddDynamic(this, &AFPSProjectile::OnHit);

	// 使用子弹移动组件ProjectileMovementComponent控制子弹
	ProjectileMovement = CreateDefaultSubobject<UProjectileMovementComponent>(TEXT("ProjectileComp"));
	ProjectileMovement->UpdatedComponent = CollisionComp;
	ProjectileMovement->InitialSpeed = 3000.f;
	ProjectileMovement->MaxSpeed = 3000.f;
	ProjectileMovement->bRotationFollowsVelocity = true;
	ProjectileMovement->bShouldBounce = true;
	ProjectileMovement->Bounciness = 0.3f;

	// 子弹生命周期（所有的Actor都有的參数）
	InitialLifeSpan = 3.0f;
}
    好咧。编译代码！

    4.回到编辑器，为了有一个对照的东西，咱们选择地面物体SM_Template_Map_Floor这个网格。而后复制一份，改变他的大小为{0.2, 0.2, 3.0}，位置为：{-230, 0, 160}.接下来，在Detail面板中，找到Physical选项，勾选计算物理Simulate Physics.而后就開始測试吧！

 5.咱们測试的时候回遇到很是多问题。退出游戏。提示

  

  不要惧怕。咱们更具这里的信息记录更改便可，通常就是说，某一个网格没有勾选物理选项。这里好像有个问题。就是最后提示地面要模拟物理个警告咱们不用管它。不然，地面就直接掉下去了。測试到最后的结果是。咱们可以用子弹把这个正方体打下去！

（十一）增添十字锚点

    UE4有一个基类HUD咱们可以扩展。

  1.新建一个类，父类HUD，命名FPSHUD

  2.咱们想要在屏幕的中央画一个十字的瞄准图片，首先咱们加入对贴图资源的引用。事实上引用方法和蓝图同样。

   （1）新建一个变量来引用它，在HUD的.h文件中面加入变量私有的便可：

private:
	/**瞄准十字贴图 */
	UTexture2D* CrosshairTex;
   （2）咱们在构造函数中引用资源，提醒一下,可以在内容浏览器中经过右键复制引用的方式找到资源的位置.
AFPSHUD::AFPSHUD(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	// 引用赋值
	static ConstructorHelpers::FObjectFinder<UTexture2D> CrosshairTexObj(TEXT("Texture2D'/Game/Texture/crosshair.crosshair'"));
	CrosshairTex = CrosshairTexObj.Object;
}

3.HUD基类有一个咱们可以重写的虚函数叫作DrawHUD。来添加咱们本身定义的需要往屏幕上加入的内容。咱们现在来重写它！

 HUD.H里面加入

virtual void DrawHUD() OVERRIDE;
 cpp里面实现

void AFPSHUD::DrawHUD()
{
	Super::DrawHUD();
	
	// Draw very simple crosshair
	
	// 找到屏幕可绘区域的中心
	FVector2D Center(Canvas->ClipX *0.5f, Canvas->ClipY *0.5f);
	
	//计算一下偏移
	FVector2D CrosshairDrawPosition((Center.X-(CrosshairTex->GetSurfaceWidth()*0.5)),(Center.Y - (CrosshairTex->GetSurfaceHeight()*0.5f)));
	
	// 画出来
	FCanvasTileItem TileItem(CrosshairDrawPosition, CrosshairTex->Resource, FLinearColor::White);
	TileItem.BlendMode = SE_BLEND_Translucent;
	Canvas->DrawItem(TileItem);
}

 3.在游戏模式的构造函数里面加入

HUDClass = AFPSHUD::StaticClass();
AMyNewFPSGameMode::AMyNewFPSGameMode(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	//DefaultPawnClass = AMyNewFPSCharacter::StaticClass();

	static ConstructorHelpers::FObjectFinder<UBlueprint> PlayerPawnObject(TEXT("Blueprint'/Game/Blueprints/BP_FPSCharacter.BP_FPSCharacter'"));
	if (PlayerPawnObject.Object != NULL)
	{
		DefaultPawnClass = (UClass*)PlayerPawnObject.Object->GeneratedClass;
	}

	HUDClass = AFPSHUD::StaticClass();
}
  注意要写上头文件。

  好了。到了这一步，就可以測试了！应该没问题！

（十二） 给角色加入动画

   1.建立动画蓝图，命名Arms_AnimBP ，选择父类:AniInstance  目标骨架为HeroFPP_Skeleton 

   

  2.咱们需要建立一个状态机来设置这些动画的状态和转化，但是要想清楚怎么样来驱动这个状态机。

这里咱们需要处理两个事情：1.人物是否是在走路。人物是否是在空中。咱们给动画蓝图加入两个变量来存储这些信息。不少其它其它建立的方法。可以參考蓝图文档。

   接下来加入两个布尔变量：bIsRunning，bIsFalling   

 3.接下来，咱们看动画蓝图里面的第一张图表：事件图表

  （1）图表中加入第一个事件节点： Event Blueprint Update Animation 

     这个节点赞成咱们当动画更新是，更新咱们设置的变量，他们是和整个游戏状态是同步的。

     
  （2）咱们可以经过询问角色的CharacterMovementComponent角色移动组件来为咱们的变量赋正确的数值。为了实现这一点，咱们需要加入一个动画控制角色的引用。

加入节点：Try Get Pawn Owner，连线：Cast to Character  （中文为：类型转换为Character）

    

 （3）例如如下图，在拖出一个节点：中文叫作得到CharacterMovement，继续加入节点Get Movement Mode.   

       （４）现在咱们可以查询CharacterMovementComponent's 组件的MovementMode 来设置bIsFalling 变量是否是真，当咱们在降落的状态的时候。连出新节点: Equal (Enum).(中文：等于枚举值)，设置其属性为Falling，得到变量bIsFalling。最后链接，例如如下图   

 （5）接着，为了决定咱们是在行走或是在站立，咱们需要得到角色的速度并且设置bIsRunning 为真。固然是在值大于零的时候。

反之，先得到速度，假设角色不是站立。那么速度数组的长度会大于零。

因此例如如下图，继续加入节点Vector Length

    最后的最后，蓝图张这个样子：


    4.接下来，来看动画蓝图的第二个图表：动绘图表

  （1）右键，新建状态机。重命名为Arms State Machine.如上图连线。

    

   （2）双击ArmStateMachine状态机节点来编辑它的图表。

      

    在这个图表中咱们需要五个状态。接下来处理第一个状态

      （1）图表右键,加入状态,命名为Idle,双击进入状态的图表.

      （2）图表中右键。查找Idle，加入Play FPP_Idle节点，例如如下图链接：

     

  （3）OK。第一个状态加入成功，接下来，依照相同的方法加入另外的四个状态    

  • Run
  • JumpStart
  • JumpEnd
  • JumpLoop
  最后效果：

   （4）接下来，咱们来加入状态之间的转换，事实上这部分，说白了。就是连线，加转换条件。

      <1>Entry->Idle

      <2>Idle->Run,双击这个线。在里面加入转换的条件

        

        双击连线，进入转换规则的图表，从变量栏中拉出bIsRunning。并得到。而后依照下图连接

        

      <3>Run->Idle

        转换条件：

       

     <4>Idle->JumpStart

      

    <5>Run->JumpStart

      

   <6>JumpStart->JumpLoop

     

     这里有一点要注意：从JumpStart到JumpLoop发生在JumpStart当即就要完毕的时候。因此在转换的规则中，咱们加入一个节点：FPP_JumpStart的剩余时间<=0.1的节点，而后如上图链接。

   <7>JumpLoop->JumpEnd

     

  <8>JumpEnd->Idle

    

  (5)终于的动绘图表例如如下：    

 5.联系动画蓝图和角色蓝图。（两个蓝图的链接！

）

  （1）编译、保存动画蓝图

  （2）打开角色蓝图BP_FPSCharacter 

  （3）看下图：

 

 最后最后最后啦！！

。！測试你的游戏吧。没问题。


  好了，到眼下为止，咱们的这个第一人称射击类游戏就算完毕了！

（十三） 总结一下今天

    今天作了例如如下一些事情：

    1.给角色加入网格，加入本身定义摄像机。调整视角，加入第二套网格

  2.加入弹药。实现射击
   （1）加入弹药类。实例化弹药
   （2） 子弹碰撞和生命周期
 3.加入HUD 十字瞄准点
 4.给角色加入动画。
 
  作了很是多事。事实上最重要的是。应该攻克了一些童鞋心中的疑惑，比方：
（一）C++和蓝图应该怎么互相有联系呢？
  答案：可以用蓝图来继承C++的类，这仅仅是他们联系的一张方式，之后，咱们甚至可以本身加入节点，无缺蓝图。
（二）C++怎样訪问蓝图
  答案：经过引用资源这样的方式
（三）C++也可以直接加入组件。方式是：
    1.加入变量
    2.构造函数中建立组件

第二部分：全篇总结

（一）整个流程：
第一步:建立project,并本身定义GameMode
    1.建立空白project
    2.设置启动关卡.
    3.本身定义GameMode
    4.改动启动游戏模式为GameMode

1.建立关卡
2.建立游戏模式
3.制做一个角色
4.控制输入：映射轴（键盘WASD--前进。鼠标X,Y--向上看，向右看），映射事件（Space--Jump）

仍是那一套。进入游戏測试。

这里总结一下：前面这么多处理输入控制的函数，事实上每一类控制要想完毕都需要三部：

1.处理映射：在项目设置中处理映射。包含轴映射（键盘鼠标都可以）。事件映射。

1.加入函数：这里要在角色的.h和.cpp文件中都要加入，一个是声明一个是实现

2.函数和输入绑定！

这一步。在角色重写的那个设置玩家输入组件的函数里面实现。
5.给角色加入网格，加入本身定义摄像机。调整视角。加入第二套网格
6.加入弹药，实现射击
  （1）加入弹药类，实例化弹药
  （2） 子弹碰撞和生命周期
7.加入HUD 十字瞄准点
8.给角色加入动画。

（二）我已近把涉及到的这几个类传上去了，仅供參考：
    1.http://pan.baidu.com/s/1dDpOhsH
    2.你们也可以直接新建一个C++的第一人称模板类的项目，啥也别作。打开看看，事实上内容是差点儿相同的。

(三)最后的说明

  最后说明，博客的主人俺仅仅是一个大三的学生，这些是我花费了本身大量的课余时间整理的，制做分享。不会考虑不论什么商业因素，假设你们喜欢，欢迎你们支持，假设文中有错误。还望你们指出。咱们一同窗习一同进步。

如需转载，请注明做者，注明CSDN本文连接。但愿你们能多多支持，之后不按期会更新一些更新的教程给你们！
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程