Controlling the Game Process

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")] // <-- identifier is generated automatically for a new component
public class EnemyLogic : Component
{

    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;

    ${#HL}$private GameController gameController = null; ${HL#}$
    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 Health health = null;
    // create a queue of route points
    private Queue<vec3> calculatedRoute = new Queue<vec3>();

    private PathRoute route = new PathRoute();
    private bool shouldUpdateRoute = true;
    private float lastCalculationTime = 0.0f;
    private bool IsTargetVisible()
    {
   	 Vec3 direction = (player.WorldPosition - intersectionSocket.WorldPosition);
   	 Vec3 p0 = intersectionSocket.WorldPosition;
   	 Vec3 p1 = p0 + direction;

   	 Unigine.Object hitObject = World.GetIntersection(p0, p1, playerIntersectionMask, hitExcludes, hitInfo);
   	 if (!hitObject)
   		 return false;

   	 return player.ID == hitObject.ID;
    }

    private void Init()
    {
   	 // initialize the parameters if the point that mives along the path 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;
   	 // get the EnemyFireController component
   	 fireController = node.GetComponent<EnemyFireController>();
   	 // get the Health component
   	 health = node.GetComponentInChildren<Health>();
   	 shouldUpdateRoute = true;
   	 lastCalculationTime = Game.Time;
   	${#HL}$ // find the GameController component
   	 gameController = ComponentSystem.FindComponentInWorld<GameController>(); ${HL#}$

    }

    private void Update()
    {

   	${#HL}$ // check the current state: if the gameplay is paused, the enemy doesn't do anything
   	 if (gameController.state != GameState.Gameplay)
   		 return; ${HL#}$

   	 // check the enemy's health
   	 if (health && health.IsDead)
   		 // remove the enemy if its health has been reduced to 0
   		 node.DeleteLater();

   	 UpdateTargetState();
   	 UpdateOrientation();
   	 UpdateRoute();

   	 // switch between the enemy's states
   	 switch (currentState)
   	 {
   		 case EnemyLogicState.Idle: ProcessIdleState(); break;
   		 case EnemyLogicState.Chase: ProcessChaseState(); break;
   		 case EnemyLogicState.Attack: ProcessAttackState(); break;
   	 }

   	 // switch the color depending on the current state
   	 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's 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 radius
   	 Visualizer.RenderSphere(attackInnerRadius, node.WorldTransform, vec4.RED);
   	 Visualizer.RenderSphere(attackOuterRadius, node.WorldTransform, vec4.RED);

   	 // visualize the route points
   	 foreach (vec3 route_point in calculatedRoute)
   		 Visualizer.RenderPoint3D(route_point + vec3.UP, 0.25f, vec4.BLACK);

    }
    private void UpdateRoute()
    {
   	 if (Game.Time - lastCalculationTime < routeRecalculationInterval)
   		 return;

   	 if (shouldUpdateRoute)
   	 {
   		 // calculate the route to the player
   		 route.Create2D(node.WorldPosition, lastSeenPosition, 1);
   		 shouldUpdateRoute = false;
   	 }

   	 // if the route is calculated
   	 if (route.IsReady)
   	 {
   		 // check if the target point of the route is reached
   		 if (route.IsReached)
   		 {
   			 // clear the points queue
   			 calculatedRoute.Clear();

   			 // add all root points to the queue
   			 for(int i = 1; i < route.NumPoints; ++i)
   				 calculatedRoute.Enqueue(route.GetPoint(i));

   			 shouldUpdateRoute = true;
   			 lastCalculationTime = Game.Time;
   		 }
   		 else
   			 // recalculate the route if the target point isn't reached
   			 shouldUpdateRoute = true;
   	 }
    }

    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()
    {
   	 // if the target (player) is visible, transition Idle -> Chase
   	 if (targetIsVisible)
   	 {
   		 // change the current state to Chase
   		 currentState = EnemyLogicState.Chase;
   	 }
    }

    private void ProcessChaseState()
    {

   	 vec3 currentVelocity = bodyRigid.LinearVelocity;
   	 currentVelocity.x = 0.0f;
   	 currentVelocity.y = 0.0f;
   	 if (calculatedRoute.Count > 0)
   	 {
   		 float distanceToTargetSqr = (float)(calculatedRoute.Peek() - node.WorldPosition).Length2;

   		 bool targetReached = (distanceToTargetSqr < reachRadius * reachRadius);
   		 if (targetReached)
   			 calculatedRoute.Dequeue();

   		 if (calculatedRoute.Count > 0)
   		 {
   			 vec3 direction = calculatedRoute.Peek() - node.WorldPosition;
   			 direction.z = 0.0f;
   			 direction.Normalize();
   			 currentVelocity.x = direction.x * speed;
   			 currentVelocity.y = direction.y * speed;
   		 }

   	 }

   	 // if the target (player) is not visible, transition Chase -> Idle
   	 if (!targetIsVisible)
   		 currentState = EnemyLogicState.Idle;

   	 // check the distance, transition Chase -> Attack
   	 else if (lastSeenDistanceSqr < attackInnerRadius * attackInnerRadius)
   	 {
   		 currentState = EnemyLogicState.Attack;
   		 currentVelocity.x = 0.0f;
   		 currentVelocity.y = 0.0f;
   		 // start shooting
   		 if (fireController)
   			 fireController.StartFiring();
   	 }

   	 bodyRigid.LinearVelocity = currentVelocity;
    }

    private void ProcessAttackState()
    {
   	 // check the distance, transition Attack -> Chase
   	 if (!targetIsVisible || lastSeenDistanceSqr > attackOuterRadius * attackOuterRadius)
   	 {
   		 currentState = EnemyLogicState.Chase;
   		 // stop shooting
   		 if (fireController)
   			 fireController.StopFiring();
   	 }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using Unigine;

[Component(PropertyGuid = "AUTOGENERATED_GUID")] // <-- identifier is generated automatically for a new component
public class PlayerLogic : Component
{
    private Health health = null;
    ${#HL}$ private GameController gameController = null; ${HL#}$
    private void Init()
    {
   	 // grab the Health component managing the player's health
   	 health = node.GetComponentInChildren<Health>();
 	 // update the player's health info
   	 ComponentSystem.FindComponentInWorld<HUD>().UpdateHealthInfo(health.health);

   	${#HL}$ // find the GameController component
   	 gameController = ComponentSystem.FindComponentInWorld<GameController>(); ${HL#}$
    }
    
    private void Update()
    {
   	 // check the player's health, and if it's killed, remove it and switch the game to the Lose state
   	 if (health && health.IsDead)
   	 {
   		${#HL}$ // remove the player
   		 node.DeleteLater();

   		 // change the gameplay state to Lose
   		 gameController.state = GameState.Lose; ${HL#}$
   	 }

   	${#HL}$ // check the game state, if it's over, remove the player
   	 else if (gameController.state != GameState.Gameplay)
           	node.DeleteLater();
   	} ${HL#}$
    
}