Создание шутера от первого лица (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, чтобы создать примитив box размером (1,1,2), добавить его в сцену и переименовать player_hit_box.

   

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

   

   Добавьте его в качестве дочернего элемента в Dummy Node hands и сбросьте его положение на родительское.

   

3. Adjust the position of the player_hit_box so that it is placed below the hands.Отрегулируйте положение player_hit_box так, чтобы он располагался под руками.
4. 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.Сделайте его невидимым, очистив его маску Viewport на вкладке Node окна Parameters. Также снимите маску 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.Щелкните правой кнопкой мыши на Dummy Object player и выберите Create -> Camera -> Dummy. Поместите созданную камеру где-нибудь в мире. При необходимости сначала включите редактирование Node Reference 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.Добавьте Dummy 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 измените значения Near Clipping и FOV Degrees ноды PlayerDummy: это поможет вам получить требуемый обзор камеры.
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.Чтобы избежать падения рук под действием силы тяжести, отрегулируйте положение ShapeCapsule Dummy Object player на вкладке Physics окна Parameters. Оно должно почти совпадать с положением ноды player_hit_box.
8. Select the player dummy object and go to the Node tab of the Parameters window.Выберите Dummy Object player и перейдите на вкладку Node окна Parameters.
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.Теперь вы можете переключиться на камеру PlayerDummy в Editor Viewport.

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. Добавьте ее в качестве дочернего элемента в Skinned Mesh hands (тот, который унаследован от Dummy Node hands).

   

3. In the Bone drop-down list, select joint_hold. This will be the bone to which the pistol will be attached.В раскрывающемся списке Bone выберите 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 и перетащите его в раздел Preview Animation параметров Skinned Mesh hands.

2. Check the Loop option and click Play.Установите флажок Loop и нажмите 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 C# Component in the drop-down list. Copy and paste the following code to the created component: Создайте новый компонент C# HandAnimationController.cs: в Asset Browser щелкните правой кнопкой мыши и выберите Create 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.SetAnimation(0, idleAnimation);
   		meshSkinned.SetAnimation(1, moveForwardAnimation);
   		meshSkinned.SetAnimation(2, moveBackwardAnimation);
   		meshSkinned.SetAnimation(3, moveRightAnimation);
   		meshSkinned.SetAnimation(4, moveLeftAnimation);
   		meshSkinned.SetAnimation(5, shootAnimation);
   
   		int animation = meshSkinned.GetAnimation(5);
   		numShootAnimationFrames = meshSkinned.GetNumAnimationFrames(animation);
   
   		// enable all animation layers
   		for (int i = 0; i < numLayers; ++i)
   			meshSkinned.SetLayerEnabled(i, true);
   	}
   
   	public void Shoot()
   	{
   		// enable the shooting animation
   		currentShootMix = 1.0f;
   		// set the animation layer frame to 0
   		currentShootFrame = 0.0f;
   	}
   
   	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.SetFrame(0, currentWalkIdleMixFrame);
   		meshSkinned.SetFrame(1, currentWalkIdleMixFrame);
   		meshSkinned.SetFrame(2, currentWalkIdleMixFrame);
   		meshSkinned.SetFrame(3, currentWalkIdleMixFrame);
   		meshSkinned.SetFrame(4, currentWalkIdleMixFrame);
   		// set the shooting animation layer frame to 0 to start animation from the beginning
   		meshSkinned.SetFrame(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 назначьте этот компонент на Skinned Mesh hands.
3. Remove the fps/hands/hands_animations/handspistolidle.fbx/handspistolidle.anim from the Preview Animation field of the Mesh Skinned section.Удалите fps/hands/hands_animations/handspistolidle.fbx/handspistolidle.anim из поля Preview Animation в разделе Mesh Skinned.

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.

   

   Назначьте (перетащите) Dummy Node player в поле Fps Controllerкомпонента HandAnimationController, чтобы он мог получать необходимые данные из first person controller для выполнения смешивания.

   

6. Save all changes and run the application logic via the UnigineEditor to check the result.Сохраните все изменения и запустите логику приложения через UnigineEditor, чтобы проверить результат.

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:Давайте внедрим новый компонент для проверки того, нажата ли кнопка стрельбы. Это предпочтительный способ, поскольку мы собираемся использовать эту логику в других компонентах:

• 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 к Dummy Node 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;
   
   	public ShootInput shootInput = 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.SetAnimation(0, idleAnimation);
   		meshSkinned.SetAnimation(1, moveForwardAnimation);
   		meshSkinned.SetAnimation(2, moveBackwardAnimation);
   		meshSkinned.SetAnimation(3, moveRightAnimation);
   		meshSkinned.SetAnimation(4, moveLeftAnimation);
   		meshSkinned.SetAnimation(5, shootAnimation);
   
   		int animation = meshSkinned.GetAnimation(5);
   		numShootAnimationFrames = meshSkinned.GetNumAnimationFrames(animation);
   
   		// enable all animation layers
   		for (int i = 0; i < numLayers; ++i)
   			meshSkinned.SetLayerEnabled(i, true);
   	}
   
   	public void Shoot()
   	{
   		// enable the shooting animation
   		currentShootMix = 1.0f;
   		// set the animation layer frame to 0
   		currentShootFrame = 0.0f;
   	}
   
   	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
   
   		if (shootInput.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.SetFrame(0, currentWalkIdleMixFrame);
   		meshSkinned.SetFrame(1, currentWalkIdleMixFrame);
   		meshSkinned.SetFrame(2, currentWalkIdleMixFrame);
   		meshSkinned.SetFrame(3, currentWalkIdleMixFrame);
   		meshSkinned.SetFrame(4, currentWalkIdleMixFrame);
   		// set the shooting animation layer frame to 0 to start animation from the beginning
   		meshSkinned.SetFrame(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, перетащите Dummy Node player в поле Shoot Input в разделе HandAnimationController.

   

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.GetDirectionFromScreen(out p0, out p1);
   
   		// 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.Добавьте компонент в 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.Назначьте Dummy Node 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() реализуют эту логику.

1. Create a VFXController.cs component and copy the code below. You can also use the existing data/fps/components/VFXController.cs component.Создайте компонент VFXController.cs и скопируйте приведенный ниже код. Вы также можете использовать существующий компонент data/fps/components/VFXController.cs.

   VFXController.cs

   Исходный код (C#)

   using System;
   using System.Collections;
   using System.Collections.Generic;
   using Unigine;
   #region Math Variables
   #if UNIGINE_DOUBLE
   using Vec3 = Unigine.dvec3;
   using Mat4 = Unigine.dmat4;
   #else
   using Vec3 = Unigine.vec3;
   using Mat4 = Unigine.mat4;
   #endif
   #endregion
   [Component(PropertyGuid = "AUTOGENERATED_GUID")] // <-- this line is generated automatically for a new component
   public class VFXController : Component
   {
   	// prefabs for hit and muzzle flash visualization
   	[ParameterFile(Filter = ".node")]
   	public string hitPrefab = null;
   
   	[ParameterFile(Filter = ".node")]
   	public string muzzleFlashPrefab = null;
   
   	public void OnShoot(Mat4 transform)
   	{
   		// if no hit prefab is specified, do nothing
   		if (string.IsNullOrEmpty(hitPrefab))
   			return;
   
   		// load the prefab for muzzle flash visualization
   		Node muzzleFlashVFX = World.LoadNode(muzzleFlashPrefab);
   		// set the muzzle flash node transformation
   		muzzleFlashVFX.WorldTransform = transform;
   	}
   
   	public void OnHit(Vec3 hitPoint, vec3 hitNormal, Unigine.Object hitObject)
   	{
   		// if no hit prefab is specified, do nothing
   		if (string.IsNullOrEmpty(hitPrefab))
   			return;
   
   		// load the prefab for hit visualization
   		Node hitVFX = World.LoadNode(hitPrefab);
   		// place the prefab in the hit point and set its direction according to the hit normal
   		hitVFX.WorldPosition = hitPoint;
   		hitVFX.SetWorldDirection(hitNormal, vec3.UP, MathLib.AXIS.Y);
   	}
   }

2. Modify the WeaponController.cs component in order to use logic of the VFXController.cs.Измените компонент WeaponController.cs, чтобы использовать логику VFXController.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 VFXController vfx = null;
   
   	public int damage = 1;
   
   	// intersection mask
   	[ParameterMask(MaskType = ParameterMaskAttribute.TYPE.INTERSECTION)]
   	public int mask = ~0;
   
   	public void Shoot()
   	{
   
   		// spawn a muzzle flash
   		if (weaponMuzzle)
   			vfx.OnShoot(weaponMuzzle.WorldTransform);
   
   		// initialize the camera point (p0) and the point of the mouse pointer (p1)
   		Vec3 p0, p1;
   		shootingCamera.GetDirectionFromScreen(out p0, out p1);
   
   		// 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);
   
   			// spawn a hit prefab at the intersection point
   			vfx.OnHit(hitInfo.Point, hitInfo.Normal, hitObject);
   
   		}
   	}
   
   	private void Update()
   	{
   		// handle input: check if the fire button is pressed
   		if (shootInput.IsShooting())
   			Shoot();
   	}
   }

3. Add the VFXController.cs component to the player dummy node.Добавьте компонент VFXController.cs к Dummy Node player.

4. Create a NodeDummy, call it muzzle, make it a child of the pistol skinned mesh, and place it near the end of the weapon muzzle.Создайте NodeDummy, назовите его muzzle, сделайте его дочерним элементом Skinned Mesh pistol и поместите его рядом с дулом оружия.

   

   

5. Select the player dummy node, assign the muzzle node to the Weapon Muzzle field in the WeaponController section.Выберите Dummy Node player, назначьте ноду muzzle полю Weapon Muzzle в разделе WeaponController.

6. Assign the player dummy node to the Vfx field in the WeaponController section.Назначьте Dummy Node player полю Vfx в разделе WeaponController.

   

7. Add the data/fps/bullet/bullet_hit.node to the Hit Prefab field of the VFXController section.Добавьте data/fps/bullet/bullet_hit.node в поле Hit Prefab раздела VFXController.
8. Add the data/fps/bullet/bullet_spawn.node to the Muzzle Flash Prefab field.

   

   Добавьте data/fps/bullet/bullet_spawn.node в поле Muzzle Flash Prefab.

   

Now you can press Start and test the shooting visual effects.Теперь вы можете нажать Start и протестировать визуальные эффекты съемки.

To control the duration of visual effects, you can add a component that will allow you to define a time interval for the node during which it will live and after which it will be deleted. The ready-to-use data/fps/components/LifeTime.cs component implements this logic.Чтобы управлять длительностью визуальных эффектов, вы можете добавить компонент, который позволит вам определить интервал времени для ноды, в течение которого он будет отображаться и после которого он удалится. Готовый к использованию компонент data/fps/components/LifeTime.cs реализует эту логику.

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 Lifetime : Component
{
	[ShowInEditor][Parameter(Tooltip = "Object's lifetime")]
	private float lifeTime = 1.0f;

	private float startTime = 0.0f;

	void Init()
	{
		// remember initialization time of an object
		startTime = Game.Time;
	}

	void Update()
	{
		// wait until the lifetime ends and delete the object
		if (Game.Time - startTime > lifeTime)
			node.DeleteLater();
	}
}

This component is already added to the bullet_hit.node and bullet_spawn.node prefabs:Этот компонент уже добавлен в префабы bullet_hit.node и bullet_spawn.node:

• For the bullet_hit.node, the Life Time parameter is set to 1 second.Для параметра bullet_hit.node параметр Life Time устанавливается равным 1 секунде.

  

• For the bullet_spawn.node, the Life Time parameter is set to 5 seconds.Для параметра bullet_spawn.node параметр Life Time устанавливается равным 5 секундам.

  

To make a HUD displaying some game info or other graphic elements, you can get an instance of the screen GUI and then add widgets as its children. We will use a WidgetSprite to make a crosshair at the center of the screen.Чтобы создать HUD, отображающий некоторую информацию об игре или другие графические элементы, вы можете получить экземпляр экранного графического интерфейса, а затем добавить виджеты в качестве его дочерних элементов. Мы будем использовать WidgetSprite, чтобы создать прицел в центре экрана.

1. Create a HUD.cs component (or use the existing one in data/fps/components).Создайте компонент HUD.cs (или используйте существующий из data/fps/components).

   HUD.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 HUD : Component
   {
   	// crosshair parameters
   	[ParameterFile]
   	public string crosshairImage = null;
   	public int crosshairSize = 16;
   
   	private WidgetSprite sprite = null;
   
   	private void Init()
   	{
   
   		// get an instance of the screen Gui
   		Gui screenGui = Gui.Get();
   
   		// add a sprite widget
   		sprite = new WidgetSprite(screenGui, crosshairImage);
   		// set the sprite size
   		sprite.Width = crosshairSize;
   		sprite.Height = crosshairSize;
   
   		// make the sprite stay in the screen center and overlap the other widgets
   		screenGui.AddChild(sprite, Gui.ALIGN_CENTER | Gui.ALIGN_OVERLAP);
   	}
   	
   	private void Update()
   	{
   		// write here code to be called before updating each render frame
   		
   	}
   }

2. Create a NodeDummy, place it somewhere in the scene, name it HUD and add the HUD.cs component to it.Создайте NodeDummy, поместите его где-нибудь в сцене, назовите его HUD и добавьте к нему компонент HUD.cs.

   

3. Add the data/fps/hud/textures/crosshair.png file to the Crosshair Image field.Добавьте файл data/fps/hud/textures/crosshair.png в поле Crosshair Image.

   

To implement robot shooting, you need a bullet prefab that will be spawned at certain points when the robot is in the Attack state.Чтобы реализовать возможность робота стрелять, вам нужен префаб пули, который будет создаваться в определенные моменты, когда робот находится в состоянии Attack.

In the EnemyFireController component we will add some shooting logic to make the robot shoot alternately from the left and right muzzle. Positions of these muzzles, where bullet nodes will be spawned, are defined by the positions of two nodes that we will assign to the Left Muzzle and Right Muzzle fields of the component.В компоненте EnemyFireController мы добавим некоторую логику стрельбы, чтобы робот стрелял попеременно с левого и правого дула. Позиции этих дул, в которых будут создаваться ноды пуль, определяются позициями двух нод, которые мы назначим в поля Left Muzzle и Right Muzzle компонента.

1. Create an EnemyFireController.cs component (or use the existing one in data/fps/components).Создайте компонент EnemyFireController.cs (или используйте существующий в data/fps/components).

   EnemyFireController.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 EnemyFireController : Component
   {
   	public Node leftMuzzle = null;
   	public Node rightMuzzle = null;
   
   	[ParameterFile]
   	public string bulletPrefab = null;
   
   	public float shootInterval = 1.0f;
   
   	private float currentTime = 0.0f;
   	private bool isLeft = false;
   	private bool isFiring = false;
   
   	public void StartFiring()
   	{
   		isFiring = true;
   	}
   
   	public void StopFiring()
   	{
   		isFiring = false;
   	}
   
   	private void Init()
   	{
   		// reset the current time
   		currentTime = 0.0f;
   		// start shooting from the right muzzle
   		isLeft = false;
   	}
   
   	private void Update()
   	{
   		// if the enemy is in the Chase state, do nothing
   		if (!isFiring)
   			return;
   
   		// update the current time
   		currentTime += Game.IFps;
   
   		// check if the next shot should be fired
   		if (currentTime > shootInterval)
   		{
   			// reset the current time
   			currentTime = 0.0f;
   			// spawn a bullet
   			Node bullet = World.LoadNode(bulletPrefab);
   
   			// set the bullet transformation
   			bullet.WorldTransform = (isLeft) ? leftMuzzle.WorldTransform : rightMuzzle.WorldTransform;
   			// switch the muzzle for the next shot
   			isLeft = !isLeft;
   		}
   	}
   }

2. Modify the EnemyLogic.cs component in order to use the implemented logic.Измените компонент EnemyLogic.cs, чтобы использовать реализованную логику.

   EnemyLogic.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
   
   // declare the enemy states
   public enum EnemyLogicState
   {
   	Idle,
   	Chase,
   	Attack,
   }
   
   [Component(PropertyGuid = "AUTOGENERATED_GUID")] // <-- this line is generated automatically for a new component
   public class EnemyLogic : Component
   {
   
   	public NavigationMesh navigationMesh = null;
   	public Node player = null;
   	public Node intersectionSocket = null;
   	public float reachRadius = 0.5f;
   	public float attackInnerRadius = 5.0f;
   	public float attackOuterRadius = 7.0f;
   	public float speed = 1.0f;
   	public float rotationStiffness = 8.0f;
   	public float routeRecalculationInterval = 3.0f;
   
   	[ParameterMask(MaskType = ParameterMaskAttribute.TYPE.INTERSECTION)]
   	public int playerIntersectionMask = ~0;
   
   	// initialize the enemy state
   	private EnemyLogicState currentState = EnemyLogicState.Idle;
   
   	private bool targetIsVisible;
   	private Vec3 lastSeenPosition;
   	private vec3 lastSeenDirection;
   	private float lastSeenDistanceSqr;
   
   	private BodyRigid bodyRigid = null;
   	private WorldIntersection hitInfo = new WorldIntersection();
   	private Node[] hitExcludes = new Node[2];
   
   	private EnemyFireController fireController = null;
   
   	private bool IsTargetVisible()
   	{
   		Vec3 direction = (player.WorldPosition - intersectionSocket.WorldPosition);
   		Vec3 p0 = intersectionSocket.WorldPosition;
   		Vec3 p1 = p0 + direction * 2.0f;
   
   		Unigine.Object hitObject = World.GetIntersection(p0, p1, playerIntersectionMask, hitExcludes, hitInfo);
   		if (hitObject == null)
   			return false;
   
   		return player.ID == hitObject.ID;
   	}
   
   	private void Init()
   	{
   		// initialize parameters of the point moving along the route inside the navigation mesh
   		route.Radius = 0.0f;
   		route.Height = 1.0f;
   		route.MaxAngle = 0.5f;
   
   		bodyRigid = node.ObjectBodyRigid;
   		hitExcludes[0] = node;
   		hitExcludes[1] = node.GetChild(0);
   
   		targetIsVisible = false;
   
   		// grab the EnemyFireController component
   		fireController = node.GetComponent<EnemyFireController>();
   
   	}
   
   	private void Update()
   	{
   
   		UpdateTargetState();
   		UpdateOrientation();
   
   		// switch between the enemy states
   		switch (currentState)
   		{
   			case EnemyLogicState.Idle: ProcessIdleState(); break;
   			case EnemyLogicState.Chase: ProcessChaseState(); break;
   			case EnemyLogicState.Attack: ProcessAttackState(); break;
   		}
   
   		// switch the colors indicating the enemy states
   		vec4 color = vec4.BLACK;
   		switch (currentState)
   		{
   			case EnemyLogicState.Idle: color = vec4.BLUE; break;
   			case EnemyLogicState.Chase: color = vec4.YELLOW; break;
   			case EnemyLogicState.Attack: color = vec4.RED; break;
   		}
   
   		// visualize the enemy states
   		Visualizer.RenderPoint3D(node.WorldPosition + vec3.UP * 2.0f, 0.25f, color);
   		Visualizer.RenderPoint3D(node.WorldPosition + vec3.UP * 3.0f, 0.25f, IsTargetVisible() ? vec4.GREEN : vec4.RED);
   		Visualizer.RenderPoint3D(lastSeenPosition, 0.1f, vec4.MAGENTA);
   
   		// visualize the attack radus
   		Visualizer.RenderSphere(attackInnerRadius, node.WorldTransform, vec4.RED);
   		Visualizer.RenderSphere(attackOuterRadius, node.WorldTransform, vec4.RED);
   
   	}
   
   	private void UpdateTargetState()
   	{
   		targetIsVisible = IsTargetVisible();
   		if (targetIsVisible)
   			lastSeenPosition = player.WorldPosition;
   
   		lastSeenDirection = (vec3)(lastSeenPosition - node.WorldPosition);
   		lastSeenDistanceSqr = lastSeenDirection.Length2;
   		lastSeenDirection.Normalize();
   	}
   
   	private void UpdateOrientation()
   	{
   		vec3 direction = lastSeenDirection;
   		direction.z = 0.0f;
   
   		quat targetRotation = new quat(MathLib.SetTo(vec3.ZERO, direction.Normalized, vec3.UP, MathLib.AXIS.Y));
   		quat currentRotation = node.GetWorldRotation();
   
   		currentRotation = MathLib.Slerp(currentRotation, targetRotation, Game.IFps * rotationStiffness);
   		node.SetWorldRotation(currentRotation);
   	}
   
   	private void ProcessIdleState()
   	{
   		// check Idle -> Chase transition
   		if (targetIsVisible)
   		{
   			// change the current state to Chase
   			currentState = EnemyLogicState.Chase;
   			// remember the player last seen position
   			lastSeenPosition = player.WorldPosition;
   		}
   	}
   
   	private void ProcessChaseState()
   	{
   
   		vec3 currentVelocity = bodyRigid.LinearVelocity;
   		currentVelocity.x = 0.0f;
   		currentVelocity.y = 0.0f;
   
   		bool targetReached = (lastSeenDistanceSqr < reachRadius * reachRadius);
   		if (!targetReached)
   		{
   			currentVelocity.x = lastSeenDirection.x * speed;
   			currentVelocity.y = lastSeenDirection.y * speed;
   		}
   
   		// check Chase->Idle transition
   		if (!targetIsVisible)
   		{
   			currentState = EnemyLogicState.Idle;
   		}
   
   		// check Chase -> Attack transition
   		if (lastSeenDistanceSqr < attackInnerRadius * attackInnerRadius && targetIsVisible)
   		{
   			currentState = EnemyLogicState.Attack;
   			currentVelocity.x = 0.0f;
   			currentVelocity.y = 0.0f;
   
   			// start firing
   			if (fireController)
   				fireController.StartFiring();
   
   		}
   
   		bodyRigid.LinearVelocity = currentVelocity;
   	}
   
   	private void ProcessAttackState()
   	{
   		// check Attack -> Chase transition
   		if (lastSeenDistanceSqr > attackOuterRadius * attackOuterRadius || !targetIsVisible)
   		{
   			currentState = EnemyLogicState.Chase;
   
   			// stop firing
   			if (fireController)
   				fireController.StopFiring();
   
   		}
   	}
   }

3. Enable editing of the robot_enemy node (if required) and assign the EnemyFireController.cs component to the robot_root dummy object. Включите редактирование ноды robot_enemy (если требуется) и назначьте компонент EnemyFireController.cs на Dummy Object robot_root.

4. Drag and drop the LeftGunMuzzle and RightGunMuzzle dummy nodes to the corresponding fields.Перетащите Dummy Node LeftGunMuzzle и RightGunMuzzle в соответствующие поля.

   

5. Drag and drop the data/fps/bullet/bullet.node to the Bullet Prefab field.Перетащите data/fps/bullet/bullet.node в поле Bullet Prefab.

   

Right Gun Muzzle SelectedВыбрано правое дуло пистолета

After spawning, a bullet should move in the right direction changing its position in the world. If the bullet intersects with an object, a hit effect should be spawned at the point of impact. And if this object can take damage (i.e., it has a Health component, see below), its health should be decreased by a certain value. Also, you can make the bullet apply an impulse to physical objects.После появления пуля должна двигаться в соответствующем направлении, меняя свое положение в мире. Если пуля пересекается с объектом, в точке попадания должен возникнуть эффект попадания. И если этот объект может наносить урон (т.е. у него есть компонент Health, см. ниже), то здоровье цели должно быть уменьшено на определенное значение. Кроме того, вы можете заставить пулю прикладывать импульс к физическим объектам.

1. Add the data/fps/bullet/bullet.node to the scene.Добавьте data/fps/bullet/bullet.node в сцену.

2. Create a Bullet.cs component and copy the following code:Создайте компонент Bullet.cs и скопируйте следующий код:

   Bullet.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 Bullet : Component
   {
   	public float speed = 10.0f;
   	public int damage = 1;
   
   	[ParameterFile]
   	public string hitPrefab = null;
   
   	[ParameterMask]
   	public int intersectionMask = ~0;
   
   	private WorldIntersectionNormal hitInfo = new WorldIntersectionNormal();
   
   	private void Init()
   	{
   	}
   	
   	private void Update()
   	{
   		// set the current position of the bullet
   		Vec3 currentPosition = node.WorldPosition;
   		// set the current world direction vector of the bullet pointing along the Y axis
   		vec3 currentDirection = node.GetWorldDirection(MathLib.AXIS.Y);
   
   		// change the bullet position
   		node.WorldPosition += currentDirection * speed * Game.IFps;
   
   		// get the first intersected object
   		Unigine.Object hitObject = World.GetIntersection(currentPosition, node.WorldPosition, intersectionMask, hitInfo);
   
   		// if no intersections are found, do nothing
   		if (hitObject == null)
   			return;
   
   		// load a prefab for hit visualization
   		Node hitEffect = World.LoadNode(hitPrefab);
   		// place the prefab in the hit point and set its direction according to the hit normal
   		hitEffect.WorldPosition = hitInfo.Point;
   		hitEffect.SetWorldDirection(hitInfo.Normal, vec3.UP, MathLib.AXIS.Y);
   
   		// delete the bullet
   		node.DeleteLater();
   	}
   }

   

3. Enable editing of the bullet node and assign the component to the bullet static mesh.Включите редактирование ноды bullet и назначьте компонент bullet на Static Mesh.
4. Drag and drop data/fps/bullet/bullet_hit.node to the Hit Prefab field.Перетащите data/fps/bullet/bullet_hit.node в поле Hit Prefab.
5. Assign the LifeTime.cs component to the bullet static mesh and set its Life Time to 5 seconds.Назначьте компонент LifeTime.cs на Static Mesh bullet и установите для него значение Life Time равным 5 секундам.