Making a First-Person Shooter (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.

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.

   

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

   

3. Adjust the position of the player_hit_box so that it is placed below the hands.

4. And switch it to Dynamic mode.

   

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.

Later, we will assign a Health component to it.

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.

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.

   

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.

   

3. Add the hands dummy node as a child to the PlayerDummy node.

   

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.
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.
6. Check the Main Player box in the parameters of the PlayerDummy to make it the main camera.

   

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.
8. Select the player dummy object and go to the Node tab of the Parameters window.
9. In the Node Components and Properties section, choose Camera -> Camera mode -> USE EXTERNAL.

10. Drag and drop the PlayerDummy node to the Camera field.

    

Now you can switch to the PlayerDummy camera in the 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.

1. In the Asset Browser, find the data/fps/pistol/pistol.fbx asset and add it to the scene.

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).

   

3. In the Bone drop-down list, select joint_hold. This will be the bone to which the pistol will be attached.

   

4. Make the pistol a child of the WorldTransformBone node. Reset its relative position and rotation to zero if needed.

   

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.

2. Check the Loop option and click 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:

   HandAnimationController.cs

   Source code (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.
3. Remove the fps/hands/hands_animations/handspistolidle.fbx/handspistolidle.anim from the Preview Animation field of the Mesh Skinned section.

4. Add animations stored in the fps/hands/hands_animations folder to the corresponding parameters.

   

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.

   

6. 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:

• In the HandAnimationController component to start the shooting animation.
• In the WeaponController component to start the shooting logic.

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.

1. Create a ShootInput.cs component and copy the following code to it.

   ShootInput.cs

   Source code (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.

   

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

   Source code (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.

   

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.

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).

1. Create a WeaponController.cs component and copy the following code:

   WeaponController.cs

   Source code (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.
3. Assign PlayerDummy to the Shooting Camera field so that the component could get information from the camera.

4. Assign the player dummy node to the Shoot Input field.

   

To view the shooting intersection points and normals, you can enable Visualizer when the application is running:

1. Open the console by pressing ~
2. Type 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.

In the component code below, the OnHit() and OnShoot() methods implement this logic.

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

   Source code (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

   Source code (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.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);
   			// 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.

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.

   

   

5. Select the player dummy node, assign the muzzle node to the Weapon Muzzle field in the WeaponController section.

6. Assign the player dummy node to the Vfx field in the WeaponController section.

   

7. Add the data/fps/bullet/bullet_hit.node to the Hit Prefab field of the VFXController section.
8. Add the data/fps/bullet/bullet_spawn.node to the Muzzle Flash Prefab field.

   

Now you can press Start and test the shooting visual effects.

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.

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:

• For the bullet_hit.node, the Life Time parameter is set to 1 second.

  

• For the bullet_spawn.node, the Life Time parameter is set to 5 seconds.

  

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.

1. Create a HUD.cs component (or use the existing one in data/fps/components).

   HUD.cs

   Source code (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.GetCurrent();
   
   		// 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.

   

3. Add the data/fps/hud/textures/crosshair.png file to the Crosshair Image field.

   

To implement robot shooting, you need a bullet prefab that will be spawned at certain points when the robot is in the Attack state.

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.

1. Create an EnemyFireController.cs component (or use the existing one in data/fps/components).

   EnemyFireController.cs

   Source code (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

   Source code (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()
   	{
   		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.

4. Drag and drop the LeftGunMuzzle and RightGunMuzzle dummy nodes to the corresponding fields.

   

5. Drag and drop the data/fps/bullet/bullet.node to the Bullet Prefab field.

   

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.

1. Add the data/fps/bullet/bullet.node to the scene.

2. Create a Bullet.cs component and copy the following code:

   Bullet.cs

   Source code (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.
4. Drag and drop data/fps/bullet/bullet_hit.node to the Hit Prefab field.
5. Assign the LifeTime.cs component to the bullet static mesh and set its Life Time to 5 seconds.