制作第一人称射击游戏(C#)

We start with adding hands, and then we will attach a pistol to them.我们从添加手开始，然后我们将为他们附加一把手枪。

In the Asset Browser, find the data/fps/hands/hands.fbx asset and add it to the scene.在资源浏览器中，找到data/fps/hands/hands.fbx资源并将其添加到场景中。

To simulate a player's body that takes damage when hit by enemy bullets, you can use an additional node:要模拟玩家的身体在被敌人的子弹击中时受到伤害，您可以使用一个额外的节点:

1. In the Menu bar, choose Create -> Primitive -> Box to create a box primitive of the (1,1,2) size, add it to the scene and rename player_hit_box.在菜单栏中，选择Create -> Primitive -> Box以创建(1,1,2)大小的box图元，将其添加到场景中并重命名player_hit_box。

   

2. Add it as a child to the hands dummy node and reset its position to the parent one.

   

   将其作为子项添加到hands虚拟节点并将其位置重置为父节点。

   

3. Adjust the position of the player_hit_box so that it is placed below the hands.调整player_hit_box的位置，使其置于手的下方。

4. And switch it to Dynamic mode.并将其切换到Dynamic模式。

   

5. Make it invisible by clearing its Viewport mask in the Node tab of the Parameters window. Also clear the Shadow mask to disable shadows rendering.通过在Parameters窗口的Node选项卡中清除其Viewport掩码，使其不可见。 还要清除Shadow蒙版以禁用阴影渲染。

Later, we will assign a Health component to it.稍后，我们将为其分配一个Health组件。

To be able to see through the eyes of the character in the UnigineEditor, you can create a new camera (PlayerDummy). It will make it easier to test the first-person setup.为了能够在UnigineEditor中通过角色的眼睛看到，您可以创建一个新的相机（PlayerDummy）。 这将使测试第一人称设置更容易。

1. Right-click the player dummy object and choose Create -> Camera -> Dummy. Place the created camera somewhere in the world. If necessary, enable editing of the player node reference first.右键单击player虚拟对象，然后选择Create -> Camera -> Dummy。 将创建的相机放置在世界的某个地方。 如有必要，请先启用player节点引用的编辑。

   

2. In the Node tab of the Parameters window, reset the position of the camera to the player position. Then adjust the rotation so that the camera is directed forward: set the rotation around the X axis to 90.

   

   在Node的标签Parameters窗口，将摄像机的位置重置为player位置。 然后调整旋转以使相机向前定向：将围绕X轴的旋转设置为90。

   

3. Add the hands dummy node as a child to the PlayerDummy node.将hands虚拟节点作为子节点添加到PlayerDummy节点。

   

4. Adjust the position of the hands so that you can see them through the PlayerDummy camera. Transformation of the player's body should also be changed.调整手的位置，以便您可以通过PlayerDummy相机看到它们。 玩家身体的改造也应该改变。
5. In the Parameters window, change Near Clipping and FOV Degrees values of the PlayerDummy node: it will help you to get the required camera view.在Parameters窗口中，更改PlayerDummy节点的Near Clipping和FOV Degrees值：它将帮助您获得所需的相机视图。
6. Check the Main Player box in the parameters of the PlayerDummy to make it the main camera.

   

   检查Main Player框中的参数PlayerDummy使其成为主摄像头。

   

7. To avoid hands falling under gravity, adjust the position of the player dummy object's ShapeCapsule in the Physics tab of the Parameters window. It should almost coincide with the position of the player_hit_box node.为了避免手在重力作用下掉落，请在Parameters窗口的Physics选项卡中调整player虚拟对象的ShapeCapsule位置。 它应该几乎与player_hit_box节点的位置重合。
8. Select the player dummy object and go to the Node tab of the Parameters window.选择player虚拟对象并转到Parameters窗口的Node选项卡。
9. In the Node Components and Properties section, choose Camera -> Camera mode -> USE EXTERNAL.在Node Components and Properties部分，选择Camera -> Camera mode -> USE EXTERNAL。

10. Drag and drop the PlayerDummy node to the Camera field.将PlayerDummy节点拖放到Camera字段。

    

Now you can switch to the PlayerDummy camera in the Editor Viewport.现在您可以在Editor Viewport中切换到PlayerDummy相机。

Our FBX model of hands contains several bones. We can attach the pistol to a particular bone of the hands to make it follow the transformations of this bone. For this purpose, you should create a WorldTransformBone node.我们的FBX手模型包含多个骨骼。 我们可以将手枪固定在手的特定骨骼上，使其遵循此骨骼的转换。 为此，您应该创建一个WorldTransformBone节点。

1. In the Asset Browser, find the data/fps/pistol/pistol.fbx asset and add it to the scene.在Asset Browser中，找到data/fps/pistol/pistol.fbx资源并将其添加到场景中。

2. In the Menu bar, choose Create -> Mesh -> SkinnedBone: a WorldTransformBone node will be created. Add it as a child to the hands skinned mesh (the one that is inherited from the hands dummy node).在菜单栏中，选择Create -> Mesh -> SkinnedBone：将创建一个WorldTransformBone节点。 将其作为子级添加到hands蒙皮网格（从hands虚拟节点继承的网格）。

   

3. In the Bone drop-down list, select joint_hold. This will be the bone to which the pistol will be attached.在骨骼下拉列表中，选择joint_hold。 这将是手枪将连接的骨头。

   

4. Make the pistol a child of the WorldTransformBone node. Reset its relative position and rotation to zero if needed.使手枪成为WorldTransformBone节点的子节点。 如果需要，将其相对位置和旋转重置为零。

   

There are also a number of animations to be used for the hands (idle, walking, shooting). You can check how a certain animation looks like, for example:还有一些动画可用于手（空闲，行走，射击）。 您可以检查某个动画的外观，例如:

1. In the Asset Browser, find the fps/hands/hands_animations/handspistolidle.fbx/handspistolidle.anim file and drag it to the Preview Animation section of the hands skinned mesh parameters.在Asset Browser中，找到fps/hands/hands_animations/handspistolidle.fbx/handspistolidle.anim文件并将其拖动到hands蒙皮网格参数的Preview Animation部分。

2. Check the Loop option and click Play.选中循环选项，然后单击Play。

   

To ensure a seamless transition, we need to play two animations simultaneously and blend them. To do so, we will use multiple layers; then we will be able to assign different weights to these layers and achieve smooth blending.为了确保无缝过渡，我们需要同时播放两个动画并混合它们。 为此，我们将使用多个图层;然后我们将能够为这些图层分配不同的权重并实现平滑混合。

The following scheme shows the blend tree we are going to use:下面的方案显示了我们要使用的混合树:

1. Create a new C# component HandAnimationController.cs: in the Asset Browser, right-click and choose Create Code -> C# Component in the drop-down list. Copy and paste the following code to the created component:创建一个新的C#组件HandAnimationController.cs：在Asset Browser中，右键单击并在下拉列表中选择Create Code -> C# Component。 将以下代码复制并粘贴到创建的组件中:

   HandAnimationController.cs

   源代码 (C#)

   using System;
   using System.Collections;
   using System.Collections.Generic;
   using Unigine;
   
   [Component(PropertyGuid = "AUTOGENERATED_GUID")] // <-- this line is generated automatically for a new component
   public class HandAnimationController : Component
   {
   	// first person controller
   	public FirstPersonController fpsController = null;
   
   	public float moveAnimationSpeed = 30.0f;
   	public float shootAnimationSpeed = 30.0f;
   	public float idleWalkMixDamping = 5.0f;
   	public float walkDamping = 5.0f;
   	public float shootDamping = 1.0f;
   
   	// animation parameters
   	[ParameterFile(Filter = ".anim")]
   	public string idleAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string moveForwardAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string moveBackwardAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string moveRightAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string moveLeftAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string shootAnimation = null;
   
   	public vec2 LocalMovementVector
   	{
   		get
   		{
   			return new vec2(
   				MathLib.Dot(fpsController.SlopeAxisY, fpsController.HorizontalVelocity),
   				MathLib.Dot(fpsController.SlopeAxisX, fpsController.HorizontalVelocity)
   			);
   		}
   		set {}
   	}
   
   	private ObjectMeshSkinned meshSkinned = null;
   	private float currentIdleWalkMix = 0.0f; // 0 means idle animation, 1 means walk animation
   	private float currentShootMix = 0.0f; // 0 means idle/walk mix, 1 means shoot animation
   	private float currentWalkForward = 0.0f;
   	private float currentWalkBackward = 0.0f;
   	private float currentWalkRight = 0.0f;
   	private float currentWalkLeft = 0.0f;
   
   	private float currentWalkIdleMixFrame = 0.0f;
   	private float currentShootFrame = 0.0f;
   	private int numShootAnimationFrames = 0;
   
   	// animation layers number
   	private const int numLayers = 6;
   
   	private void Init()
   	{
   		// grab the node with the current component assigned
   		// and cast it to the ObjectMeshSkinned type
   		meshSkinned = node as ObjectMeshSkinned;
   
   		// set the number of animation layers for the node
   		meshSkinned.NumLayers = numLayers;
   
   		// set animation for each animation layer
   		meshSkinned.SetLayerAnimationFilePath(0, idleAnimation);
   		meshSkinned.SetLayerAnimationFilePath(1, moveForwardAnimation);
   		meshSkinned.SetLayerAnimationFilePath(2, moveBackwardAnimation);
   		meshSkinned.SetLayerAnimationFilePath(3, moveRightAnimation);
   		meshSkinned.SetLayerAnimationFilePath(4, moveLeftAnimation);
   		meshSkinned.SetLayerAnimationFilePath(5, shootAnimation);
   
   		numShootAnimationFrames = meshSkinned.GetLayerNumFrames(5);
   
   		// enable all animation layers
   		for (int i = 0; i < numLayers; ++i)
   			meshSkinned.SetLayerEnabled(i, true);
   	}
   ${#HL}$
   	public void Shoot()
   	{
   		// enable the shooting animation
   		currentShootMix = 1.0f;
   		// set the animation layer frame to 0
   		currentShootFrame = 0.0f;
   	}  ${HL#}$
   
   	private void Update()
   	{
   		vec2 movementVector = LocalMovementVector;
   	
   		// check if the character is moving
   		bool isMoving = movementVector.Length2 > MathLib.EPSILON;
   
   		// handle input: check if the fire button is pressed
   		bool isShooting = Input.IsMouseButtonDown(Input.MOUSE_BUTTON.LEFT);
   		if (isShooting)
   			Shoot();
   		// calculate the target values for the layer weights
   		float targetIdleWalkMix = (isMoving) ? 1.0f : 0.0f;
   		float targetWalkForward = (float) MathLib.Max(0.0f, movementVector.x);
   		float targetWalkBackward = (float) MathLib.Max(0.0f, -movementVector.x);
   		float targetWalkRight = (float) MathLib.Max(0.0f, movementVector.y);
   		float targetWalkLeft = (float) MathLib.Max(0.0f, -movementVector.y);
   
   		// apply the current layer weights
   		float idleWeight = 1.0f - currentIdleWalkMix;
   		float walkMixWeight = currentIdleWalkMix;
   		float shootWalkIdleMix = 1.0f - currentShootMix;
   
   		meshSkinned.SetLayerWeight(0, shootWalkIdleMix * idleWeight);
   		meshSkinned.SetLayerWeight(1, shootWalkIdleMix * walkMixWeight * currentWalkForward);
   		meshSkinned.SetLayerWeight(2, shootWalkIdleMix * walkMixWeight * currentWalkBackward);
   		meshSkinned.SetLayerWeight(3, shootWalkIdleMix * walkMixWeight * currentWalkRight);
   		meshSkinned.SetLayerWeight(4, shootWalkIdleMix * walkMixWeight * currentWalkLeft);
   		meshSkinned.SetLayerWeight(5, currentShootMix);
   
   		// update the animation frames: set the same frame for the animation layers to keep them in sync
   		meshSkinned.SetLayerFrame(0, currentWalkIdleMixFrame);
   		meshSkinned.SetLayerFrame(1, currentWalkIdleMixFrame);
   		meshSkinned.SetLayerFrame(2, currentWalkIdleMixFrame);
   		meshSkinned.SetLayerFrame(3, currentWalkIdleMixFrame);
   		meshSkinned.SetLayerFrame(4, currentWalkIdleMixFrame);
   		// set the shooting animation layer frame to 0 to start animation from the beginning
   		meshSkinned.SetLayerFrame(5, currentShootFrame);
   
   		currentWalkIdleMixFrame += moveAnimationSpeed * Game.IFps;
   		currentShootFrame = MathLib.Min(currentShootFrame + shootAnimationSpeed * Game.IFps, numShootAnimationFrames);
   
   		// smoothly update the current weight values
   		currentIdleWalkMix = MathLib.Lerp(currentIdleWalkMix, targetIdleWalkMix, idleWalkMixDamping * Game.IFps);
   
   		currentWalkForward = MathLib.Lerp(currentWalkForward, targetWalkForward, walkDamping * Game.IFps);
   		currentWalkBackward = MathLib.Lerp(currentWalkBackward, targetWalkBackward, walkDamping * Game.IFps);
   		currentWalkRight = MathLib.Lerp(currentWalkRight, targetWalkRight, walkDamping * Game.IFps);
   		currentWalkLeft = MathLib.Lerp(currentWalkLeft, targetWalkLeft, walkDamping * Game.IFps);
   
   		currentShootMix = MathLib.Lerp(currentShootMix, 0.0f, shootDamping * Game.IFps);
   	}
   }

2. In the UnigineEditor, assign this component to the hands skinned mesh.在UnigineEditor中，将此组件分配给hands蒙皮网格。
3. Remove the fps/hands/hands_animations/handspistolidle.fbx/handspistolidle.anim from the Preview Animation field of the Mesh Skinned section.从Mesh Skinned部分的Preview Animation字段中移除fps/hands/hands_animations/handspistolidle.fbx/handspistolidle.anim。

4. Add animations stored in the fps/hands/hands_animations folder to the corresponding parameters.将存储在fps/hands/hands_animations文件夹中的动画添加到相应的参数中。

   

5. Assign (drag and drop) the player dummy node to the Fps Controller field of the HandAnimationController component so that it could get required data from the player's first person controller to perform blending.

   

   分配（拖放）player虚拟节点到Fps Controller领域的HandAnimationController组件，以便它可以从玩家的first person controller来执行混合。

   

6. Save all changes and run the application logic via the UnigineEditor to check the result.Save all changes and run the application logic via the UnigineEditor to check the result.

Let's implement a new component for checking if the fire button is pressed. This is the preferred way as we are going to use this logic in the other components:让我们实现一个新的组件，用于检查是否按下了fire按钮。 这是首选的方式，因为我们将在其他组件中使用此逻辑:

• In the HandAnimationController component to start the shooting animation.在HandAnimationController组件中开始拍摄动画。
• In the WeaponController component to start the shooting logic.在WeaponController组件中启动拍摄逻辑。

In this component, you can also define a button that acts as a fire button.在该组件中，您还可以定义一个充当消防按钮的按钮。

To handle user input, use one of the Input class functions to check if the given button is pressed.要处理用户输入，请使用Input类函数之一来检查是否按下了给定的按钮。

1. Create a ShootInput.cs component and copy the following code to it.创建一个ShootInput.cs组件并将以下代码复制到其中。

   ShootInput.cs

   源代码 (C#)

   using System;
   using System.Collections;
   using System.Collections.Generic;
   using Unigine;
   
   [Component(PropertyGuid = "AUTOGENERATED_GUID")] // <-- this line is generated automatically for a new component
   public class ShootInput : Component
   {	
   	public bool IsShooting()
   	{
   		return Input.IsMouseButtonDown(Input.MOUSE_BUTTON.LEFT);
   	}
   }

2. Add the ShootInput.cs component to the player dummy node.将ShootInput.cs组件添加到player虚拟节点。

   

3. Modify the HandAnimationController.cs component in order to use logic of the ShootInput.cs. Replace your current code with the following one:修改HandAnimationController.cs组件以便使用ShootInput.cs的逻辑。 将当前代码替换为以下代码:

   HandAnimationController.cs

   源代码 (C#)

   using System;
   using System.Collections;
   using System.Collections.Generic;
   using Unigine;
   
   [Component(PropertyGuid = "AUTOGENERATED_GUID")] // <-- this line is generated automatically for a new component
   public class HandAnimationController : Component
   {
   	// first person controller
   	public FirstPersonController fpsController = null;
   
   ${#HL}$	public ShootInput shootInput = null;  ${HL#}$
   
   	public float moveAnimationSpeed = 30.0f;
   	public float shootAnimationSpeed = 30.0f;
   	public float idleWalkMixDamping = 5.0f;
   	public float walkDamping = 5.0f;
   	public float shootDamping = 1.0f;
   
   	// animation parameters
   	[ParameterFile(Filter = ".anim")]
   	public string idleAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string moveForwardAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string moveBackwardAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string moveRightAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string moveLeftAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string shootAnimation = null;
   
   	public vec2 LocalMovementVector
   	{
   		get
   		{
   			return new vec2(
   				MathLib.Dot(fpsController.SlopeAxisY, fpsController.HorizontalVelocity),
   				MathLib.Dot(fpsController.SlopeAxisX, fpsController.HorizontalVelocity)
   			);
   		}
   		set {}
   	}
   
   	private ObjectMeshSkinned meshSkinned = null;
   	private float currentIdleWalkMix = 0.0f; // 0 means idle animation, 1 means walk animation
   	private float currentShootMix = 0.0f; // 0 means idle/walk mix, 1 means shoot animation
   	private float currentWalkForward = 0.0f;
   	private float currentWalkBackward = 0.0f;
   	private float currentWalkRight = 0.0f;
   	private float currentWalkLeft = 0.0f;
   
   	private float currentWalkIdleMixFrame = 0.0f;
   	private float currentShootFrame = 0.0f;
   	private int numShootAnimationFrames = 0;
   
   	// animation layers number
   	private const int numLayers = 6;
   
   	private void Init()
   	{
   		// grab the node with the current component assigned
   		// and cast it to the ObjectMeshSkinned type
   		meshSkinned = node as ObjectMeshSkinned;
   
   		// set the number of animation layers for the node
   		meshSkinned.NumLayers = numLayers;
   
   		// set animation for each animation layer
   		meshSkinned.SetLayerAnimationFilePath(0, idleAnimation);
   		meshSkinned.SetLayerAnimationFilePath(1, moveForwardAnimation);
   		meshSkinned.SetLayerAnimationFilePath(2, moveBackwardAnimation);
   		meshSkinned.SetLayerAnimationFilePath(3, moveRightAnimation);
   		meshSkinned.SetLayerAnimationFilePath(4, moveLeftAnimation);
   		meshSkinned.SetLayerAnimationFilePath(5, shootAnimation);
   
   		numShootAnimationFrames = meshSkinned.GetLayerNumFrames(5);
   
   		// enable all animation layers
   		for (int i = 0; i < numLayers; ++i)
   			meshSkinned.SetLayerEnabled(i, true);
   	}
   ${#HL}$
   	public void Shoot()
   	{
   		// enable the shooting animation
   		currentShootMix = 1.0f;
   		// set the animation layer frame to 0
   		currentShootFrame = 0.0f;
   	}  ${HL#}$
   
   	private void Update()
   	{
   		vec2 movementVector = LocalMovementVector;
   	
   		// check if the character is moving
   		bool isMoving = movementVector.Length2 > MathLib.EPSILON;
   
   		// handle input: check if the fire button is pressed
   ${#HL}$
   		if (shootInput.IsShooting())
   			Shoot();  ${HL#}$
   		// calculate the target values for the layer weights
   		float targetIdleWalkMix = (isMoving) ? 1.0f : 0.0f;
   		float targetWalkForward = (float) MathLib.Max(0.0f, movementVector.x);
   		float targetWalkBackward = (float) MathLib.Max(0.0f, -movementVector.x);
   		float targetWalkRight = (float) MathLib.Max(0.0f, movementVector.y);
   		float targetWalkLeft = (float) MathLib.Max(0.0f, -movementVector.y);
   
   		// apply the current layer weights
   		float idleWeight = 1.0f - currentIdleWalkMix;
   		float walkMixWeight = currentIdleWalkMix;
   		float shootWalkIdleMix = 1.0f - currentShootMix;
   
   		meshSkinned.SetLayerWeight(0, shootWalkIdleMix * idleWeight);
   		meshSkinned.SetLayerWeight(1, shootWalkIdleMix * walkMixWeight * currentWalkForward);
   		meshSkinned.SetLayerWeight(2, shootWalkIdleMix * walkMixWeight * currentWalkBackward);
   		meshSkinned.SetLayerWeight(3, shootWalkIdleMix * walkMixWeight * currentWalkRight);
   		meshSkinned.SetLayerWeight(4, shootWalkIdleMix * walkMixWeight * currentWalkLeft);
   		meshSkinned.SetLayerWeight(5, currentShootMix);
   
   		// update the animation frames: set the same frame for the animation layers to keep them in sync
   		meshSkinned.SetLayerFrame(0, currentWalkIdleMixFrame);
   		meshSkinned.SetLayerFrame(1, currentWalkIdleMixFrame);
   		meshSkinned.SetLayerFrame(2, currentWalkIdleMixFrame);
   		meshSkinned.SetLayerFrame(3, currentWalkIdleMixFrame);
   		meshSkinned.SetLayerFrame(4, currentWalkIdleMixFrame);
   		// set the shooting animation layer frame to 0 to start animation from the beginning
   		meshSkinned.SetLayerFrame(5, currentShootFrame);
   
   		currentWalkIdleMixFrame += moveAnimationSpeed * Game.IFps;
   		currentShootFrame = MathLib.Min(currentShootFrame + shootAnimationSpeed * Game.IFps, numShootAnimationFrames);
   
   		// smoothly update the current weight values
   		currentIdleWalkMix = MathLib.Lerp(currentIdleWalkMix, targetIdleWalkMix, idleWalkMixDamping * Game.IFps);
   
   		currentWalkForward = MathLib.Lerp(currentWalkForward, targetWalkForward, walkDamping * Game.IFps);
   		currentWalkBackward = MathLib.Lerp(currentWalkBackward, targetWalkBackward, walkDamping * Game.IFps);
   		currentWalkRight = MathLib.Lerp(currentWalkRight, targetWalkRight, walkDamping * Game.IFps);
   		currentWalkLeft = MathLib.Lerp(currentWalkLeft, targetWalkLeft, walkDamping * Game.IFps);
   
   		currentShootMix = MathLib.Lerp(currentShootMix, 0.0f, shootDamping * Game.IFps);
   	}
   }

4. Select the hands node, drag and drop the player dummy node to the Shoot Input field in the HandAnimationController section.选择hands节点，将player虚拟节点拖放到HandAnimationController部分的Shoot Input字段中。

   

To implement shooting, you can use the properties of the PlayerDummy camera. This camera has its -Z axis pointing at the middle of the screen. So, you can do a ray cast from the camera to the middle of the screen, get the intersection, and check if you hit something.要实现拍摄，可以使用PlayerDummy相机的属性。 这个相机有它的-Z轴指向屏幕的中间。 因此，您可以从相机到屏幕中间进行光线投射，获取交叉点，并检查您是否击中了某些东西。

In the component code below, we will store two points (p0, p1): the camera point and the point of the mouse pointer. GetIntersection() method will cast a ray from p0 to p1 and check the intersection with an object's surface that has the matching intersection mask. If we get the intersection, the method returns hitObject and hitInfo values (the intersection point and normal).在下面的组件代码中，我们将存储两个点（p0，p1）：相机点和鼠标指针的点。 GetIntersection()方法将从p0投射一条射线到p1，并检查与具有匹配相交掩码的对象表面的相交。 如果我们得到交点，该方法返回hitObject和hitInfo值（交点和法线）。

1. Create a WeaponController.cs component and copy the following code:创建一个WeaponController.cs组件并复制以下代码:

   WeaponController.cs

   源代码 (C#)

   using System;
   using System.Collections;
   using System.Collections.Generic;
   using Unigine;
   
   #region Math Variables
   #if UNIGINE_DOUBLE
   using Vec3 = Unigine.dvec3;
   #else
   using Vec3 = Unigine.vec3;
   #endif
   #endregion
   
   [Component(PropertyGuid = "AUTOGENERATED_GUID")] // <-- this line is generated automatically for a new component
   public class WeaponController : Component
   {
   	public PlayerDummy shootingCamera = null;
   	public ShootInput shootInput = null;
   	public NodeDummy weaponMuzzle = null;
   	public int damage = 1;
   
   	// intersection mask
   	[ParameterMask(MaskType = ParameterMaskAttribute.TYPE.INTERSECTION)]
   	public int mask = ~0;
   
   	public void Shoot()
   	{
   		// initialize the camera point (p0) and the point of the mouse pointer (p1)
   		Vec3 p0, p1;
   		shootingCamera.GetDirectionFromMainWindow(out p0, out p1, Input.MousePosition.x, Input.MousePosition.y);
   
   		// create an intersection normal
   		WorldIntersectionNormal hitInfo = new WorldIntersectionNormal();
   		// get the first object intersected by the (p0,p1) line
   		Unigine.Object hitObject = World.GetIntersection(p0, p1, mask, hitInfo);
   
   		// if the intersection is found
   		if (hitObject)
   		{
   			// render the intersection normal
   			Visualizer.RenderVector(hitInfo.Point, hitInfo.Point + hitInfo.Normal, vec4.RED, 0.25f, false, 2.0f);
   		}
   	}
   
   	private void Update()
   	{
   		// handle input: check if the fire button is pressed
   		if (shootInput.IsShooting())
   			Shoot();
   	}
   }

2. Add the component to the player dummy node.将组件添加到player虚拟节点。
3. Assign PlayerDummy to the Shooting Camera field so that the component could get information from the camera.将PlayerDummy分配给Shooting Camera字段，以便组件可以从相机获取信息。

4. Assign the player dummy node to the Shoot Input field.将player虚拟节点分配给Shoot Input字段。

   

To view the shooting intersection points and normals, you can enable Visualizer when the application is running:要查看拍摄交叉点和法线，您可以在应用程序运行时启用Visualizer:

1. Open the console by pressing ~按~打开控制台
2. Type show_visualizer 1.类型show_visualizer 1。

Visual effects for shooting can be implemented in a separate component. You can get information about the hit point and spawn a hit prefab at this point oriented along the hit normal. For the muzzle flash, you can attach a NodeDummy to the muzzle of the pistol, and spawn a muzzle flash prefab at this position.用于拍摄的视觉效果可以在单独的组件中实现。 您可以获得有关命中点的信息，并在该点沿命中法线定向生成命中预制件。 对于枪口闪光，你可以在手枪的枪口上附加一个NodeDummy，并在这个位置产生一个枪口闪光预制件。

In the component code below, the OnHit() and OnShoot() methods implement this logic.在下面的组件代码中，OnHit()和OnShoot()方法实现了这个逻辑。