r.nikolin
/
rabidus-test
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
rabidus-test/Assets/SCSM/SciFiShipController/Scripts/AI/ShipAIInputModule.cs

2495 lines
131 KiB
C#
Raw Blame History

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
// Sci-Fi Ship Controller. Copyright (c) 2018-2023 SCSM Pty Ltd. All rights reserved.
namespace SciFiShipController
{
[AddComponentMenu("Sci-Fi Ship Controller/Ship Components/Ship AI Input Module")]
[HelpURL("http://scsmmedia.com/ssc-documentation")]
[RequireComponent(typeof(ShipControlModule))]
[DisallowMultipleComponent]
public class ShipAIInputModule : MonoBehaviour
{
#region Public Enumerations
public enum AIMovementAlgorithm
{
//LeftAndRightOnly = 10,
//LeftAndRightStrafeOnly = 11,
PlanarFlight = 20,
PlanarFlightBanking = 25,
Full3DFlight = 30
}
public enum AIObstacleAvoidanceQuality
{
Off = 5,
Low = 10,
Medium = 15,
High = 20
}
public enum AIPathFollowingQuality
{
VeryLow = 5,
Low = 10,
Medium = 15,
High = 20
}
public enum AIStateActionInfo
{
/// <summary>
/// The current state is a custom state.
/// </summary>
Custom = 0,
/// <summary>
/// The current state is Idle. The current state action is idling.
/// </summary>
Idle = 5,
/// <summary>
/// The current state is Move To. The current state action is moving towards TargetPosition.
/// </summary>
MoveToSeekPosition = 10,
/// <summary>
/// The current state is Move To. The current state action is moving towards TargetLocation.
/// </summary>
MoveToSeekLocation = 11,
/// <summary>
/// The current state is Move To. The current state action is following TargetPath.
/// </summary>
MoveToFollowPath = 12,
/// <summary>
/// The current state is Dogfight. The current state action is attacking TargetShip.
/// </summary>
DogfightAttackShip = 20,
/// <summary>
/// The current state is Docking. The current state action is moving towards TargetPosition and TargetRotation.
/// </summary>
Docking = 25,
/// <summary>
/// The current state is Strafing Run. The current state action is moving towards and attacking TargetPosition
/// before moving away from TargetPosition when within TargetRadius.
/// </summary>
StrafingRun = 30
}
#endregion
#region Public Variables and Properties
/// <summary>
/// If enabled, the Initialise() will be called as soon as Awake() runs. This should be disabled if you are
/// instantiating the ShipAIInputModule through code.
/// </summary>
public bool initialiseOnAwake = false;
public bool IsInitialised { get { return isInitialised; } }
/// <summary>
/// The algorithm used for calculating AI movement.
/// </summary>
public AIMovementAlgorithm movementAlgorithm = AIMovementAlgorithm.PlanarFlightBanking;
/// <summary>
/// The quality of obstacle avoidance for this AI ship. Lower quality settings will improve performance.
/// </summary>
public AIObstacleAvoidanceQuality obstacleAvoidanceQuality = AIObstacleAvoidanceQuality.Medium;
/// <summary>
/// Layermask determining which layers will be detected as obstacles when raycasted against. Exclude layers that
/// you don't want the AI ship to try and avoid using obstacle avoidance.
/// </summary>
public LayerMask obstacleLayerMask = Physics.AllLayers;
/// <summary>
/// The starting offset for obstacle avoidance raycasts on the z-axis. Increase this value to move the
/// starting point for obstacle avoidance raycasts forward and hence avoid detecting collisions with
/// frontally-placed colliders within the ship itself.
/// </summary>
public float raycastStartOffsetZ = 0f;
/// <summary>
/// The quality of path following for this AI ship. Lower quality settings will improve performance.
/// </summary>
public AIPathFollowingQuality pathFollowingQuality = AIPathFollowingQuality.Medium;
/// <summary>
/// The max speed for the ship in metres per second.
/// </summary>
public float maxSpeed = 1000f;
/// <summary>
/// The supposed radius of the ship (approximated as a sphere) used for obstacle avoidance.
/// </summary>
public float shipRadius = 5f;
/// <summary>
/// The accuracy of the ship at shooting at a target. A value of 1 is perfect accuracy, while a value of 0
/// is the lowest accuracy.
/// </summary>
[Range(0f, 1f)] public float targetingAccuracy = 1f;
/// <summary>
/// The maximum angle of the ship to the target at which it will fire.
/// </summary>
public float fireAngle = 10f;
/// <summary>
/// The maximum bank angle (in degrees) the ship should bank at while turning.
/// Only relevant when movementAlgorithm is set to PlanarFlightBanking.
/// </summary>
[Range(10f, 90f)] public float maxBankAngle = 30f;
/// <summary>
/// The turning angle (in degrees) to the target position at which the AI will bank at the maxBankAngle. Lower values
/// will result in the AI banking at a steeper angle for lower turning angles.
/// Only relevant when movementAlgorithm is set to PlanarFlightBanking.
/// </summary>
[Range(5f, 90f)] public float maxBankTurnAngle = 15f;
/// <summary>
/// The maximum pitch angle (in degrees) that the AI is able to use to pitch towards the target position.
/// Only relevant when movementAlgorithm is set to PlanarFlight or PlanarFlightBanking.
/// </summary>
[Range(5f, 90f)] public float maxPitchAngle = 90f;
/// <summary>
/// Only use pitch to steer when the ship is within the threshold (in degrees) of the correct yaw/roll angle.
/// Only relevant when movementAlgorithm is set to Full3DFlight.
/// </summary>
[Range(10f, 90f)] public float turnPitchThreshold = 30f;
/// <summary>
/// When turning, will the ship favour yaw (i.e. turning using yaw then pitching) or roll (i.e. turning using roll
/// then pitching) to achieve the turn? Lower values will favour yaw while higher values will favour roll.
/// Only relevant when movementAlgorithm is set to Full3DFlight.
/// </summary>
[Range(0f, 1f)] public float rollBias = 0.5f;
// Used for Debugging in the Editor
public Vector3 DesiredLocalVelocity { get { return desiredLocalVelocity; } }
public Vector3 CurrentLocalVelocity { get { return currentLocalVelocity; } }
public ShipInput GetShipInput { get { return shipInput; } }
/// <summary>
/// Get a reference to the ShipControlModule component attached to this Ship AI Input Module.
/// This is only available if the Ship AI Input Module is initialised. If not, it will return null.
/// </summary>
public ShipControlModule GetShipControlModule { get { if (isInitialised) { return shipControlModule; } else { return null; } } }
/// <summary>
/// Get a reference to the Ship instance which is part of an initialised ShipControlModule.
/// If the Ship AI Input Module or Ship Control Module are not initialised, it will return null.
/// </summary>
public Ship GetShip { get { if (isInitialised) { if (shipControlModule != null && shipControlModule.IsInitialised) { return shipControlModule.shipInstance; } else { return null; } } else { return null; } } }
/// <summary>
/// Get the identity of the ship this AI module is attached to. It will return 0 if the ship is not initialised.
/// </summary>
public int GetShipId { get { if (isInitialised) { if (shipControlModule != null && shipControlModule.IsInitialised) { return shipControlModule.shipInstance.shipId; } else { return 0; } } else { return 0; } } }
#endregion
#region Public Data Discard variables (Advanced)
/// <summary>
/// Should we use or discard data from the horizontal axis?
/// Call ReinitialiseDiscardData() after modifying this at runtime.
/// </summary>
public bool isHorizontalDataDiscarded;
/// <summary>
/// Should we use or discard data from the vertical axis?
/// Call ReinitialiseDiscardData() after modifying this at runtime.
/// </summary>
public bool isVerticalDataDiscarded;
/// <summary>
/// Should we use or discard data from the longitudinal axis?
/// Call ReinitialiseDiscardData() after modifying this at runtime.
/// </summary>
public bool isLongitudinalDataDiscarded;
/// <summary>
/// Should we use or discard data from the pitch axis?
/// Call ReinitialiseDiscardData() after modifying this at runtime.
/// </summary>
public bool isPitchDataDiscarded;
/// <summary>
/// Should we use or discard data from the yaw axis?
/// Call ReinitialiseDiscardData() after modifying this at runtime.
/// </summary>
public bool isYawDataDiscarded;
/// <summary>
/// Should we use or discard data from the roll axis?
/// Call ReinitialiseDiscardData() after modifying this at runtime.
/// </summary>
public bool isRollDataDiscarded;
/// <summary>
/// Should we use or discard data from the primaryFire button?
/// Call ReinitialiseDiscardData() after modifying this at runtime.
/// </summary>
public bool isPrimaryFireDataDiscarded;
/// <summary>
/// Should we use or discard data from the secondaryFire button?
/// Call ReinitialiseDiscardData() after modifying this at runtime.
/// </summary>
public bool isSecondaryFireDataDiscarded;
/// <summary>
/// Should we use or discard data from the dock button?
/// Call ReinitialiseDiscardData() after modifying this at runtime.
/// </summary>
public bool isDockDataDiscarded;
#endregion
#region Public Delegates
public delegate void CallbackCustomIdleBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
public delegate void CallbackCustomSeekBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
public delegate void CallbackCustomFleeBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
public delegate void CallbackCustomPursuitBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
public delegate void CallbackCustomEvasionBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
public delegate void CallbackCustomSeekArrivalBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
public delegate void CallbackCustomSeekMovingArrivalBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
public delegate void CallbackCustomPursuitArrivalBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
//public delegate void CallbackCustomFollowBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
//public delegate void CallbackCustomAvoidBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
//public delegate void CallbackCustomBlockCylinderBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
//public delegate void CallbackCustomBlockConeBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
public delegate void CallbackCustomUnblockCylinderBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
public delegate void CallbackCustomUnblockConeBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
public delegate void CallbackCustomObstacleAvoidanceBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
public delegate void CallbackCustomFollowPathBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
public delegate void CallbackCustomDockBehaviour(AIBehaviourInput behaviourInput, AIBehaviourOutput behaviourOutput);
public delegate void CallbackStateMethod(AIStateMethodParameters stateMethodParameters);
public delegate void CallbackCompletedStateAction(ShipAIInputModule shipAIInputModule);
public delegate void CallbackOnStateChange(ShipAIInputModule shipAIInputModule, int currentStateId, int previousStateId);
// These callback methods allow a game developer to supply a custom method (delegate) that gets called instead
// of the default behaviour.
/// <summary>
/// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomIdle".
/// </summary>
public CallbackCustomIdleBehaviour callbackCustomIdleBehaviour = null;
/// <summary>
/// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomSeek".
/// </summary>
public CallbackCustomSeekBehaviour callbackCustomSeekBehaviour = null;
/// <summary>
/// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomFlee".
/// </summary>
public CallbackCustomFleeBehaviour callbackCustomFleeBehaviour = null;
/// <summary>
/// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomPursuit".
/// </summary>
public CallbackCustomPursuitBehaviour callbackCustomPursuitBehaviour = null;
/// <summary>
/// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomEvasion".
/// </summary>
public CallbackCustomEvasionBehaviour callbackCustomEvasionBehaviour = null;
/// <summary>
/// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomSeekArrival".
/// </summary>
public CallbackCustomSeekArrivalBehaviour callbackCustomSeekArrivalBehaviour = null;
/// <summary>
/// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomSeekMovingArrival".
/// </summary>
public CallbackCustomSeekMovingArrivalBehaviour callbackCustomSeekMovingArrivalBehaviour = null;
/// <summary>
/// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomPursuitArrival".
/// </summary>
public CallbackCustomPursuitArrivalBehaviour callbackCustomPursuitArrivalBehaviour = null;
///// <summary>
///// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomAvoid".
///// </summary>
//public CallbackCustomAvoidBehaviour callbackCustomAvoidBehaviour = null;
///// <summary>
///// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomFollow".
///// </summary>
//public CallbackCustomFollowBehaviour callbackCustomFollowBehaviour = null;
/// <summary>
/// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomUnblockCylinder".
/// </summary>
public CallbackCustomUnblockCylinderBehaviour callbackCustomUnblockCylinderBehaviour = null;
/// <summary>
/// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomUnblockCone".
/// </summary>
public CallbackCustomUnblockConeBehaviour callbackCustomUnblockConeBehaviour = null;
/// <summary>
/// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomObstacleAvoidance".
/// </summary>
public CallbackCustomObstacleAvoidanceBehaviour callbackCustomObstacleAvoidanceBehaviour = null;
/// <summary>
/// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomFollowPath".
/// </summary>
public CallbackCustomFollowPathBehaviour callbackCustomFollowPathBehaviour = null;
/// <summary>
/// The name of the developer-supplied custom method that is called when the AIBehaviourType is "CustomDock".
/// </summary>
public CallbackCustomDockBehaviour callbackCustomDockBehaviour = null;
/// <summary>
/// The name of the developer-supplied custom method that is called when the current state action has been completed.
/// Must have 1 parameter of type ShipAIInputModule.
/// </summary>
public CallbackCompletedStateAction callbackCompletedStateAction = null;
/// <summary>
/// The name of the developer-supplied custom method that gets called whenever the state changes.
/// Must have 3 parameters of type: ShipAIInputModule, int (currentStateId), and int (previousStateId).
/// </summary>
public CallbackOnStateChange callbackOnStateChange = null;
#endregion
#region Private Variables
private ShipControlModule shipControlModule;
private bool isInitialised = false;
// State variables
private Vector3 targetPosition = Vector3.zero;
private Quaternion targetRotation = Quaternion.identity;
private LocationData targetLocation = null;
private PathData targetPath = null;
private int currentTargetPathLocationIndex = -1;
private int prevTargetPathLocationIndex = -1;
private float currentTargetPathTValue = 0f;
private Ship targetShip = null;
private List<Ship> shipsToEvade = null;
private List<SurfaceTurretModule> surfaceTurretsToEvade = null;
private float targetRadius = 10f;
private float targetDistance = 1f;
private float targetAngularDistance = 1f;
private Vector3 targetVelocity = Vector3.zero;
private float targetTime = 0f;
private bool hasCompletedStateAction = false;
private int currentStateStageIndex = 0;
private ShipInput shipInput;
private List<AIBehaviourInput> behaviourInputsList;
private List<AIBehaviourOutput> behaviourOutputsList;
private int behavioursListCount = 10;
private AIBehaviourOutput combinedBehaviourOutput;
private Vector3 lastBehaviourInputTarget = Vector3.zero;
private AIState currentState = null;
private AIStateMethodParameters stateMethodParameters;
private PIDController pitchPIDController;
private PIDController yawPIDController;
private PIDController rollPIDController;
private PIDController verticalPIDController;
private PIDController horizontalPIDController;
private PIDController longitudinalPIDController;
private float targetRoll = 0f, targetYaw = 0f, targetPitch = 0f;
private float currentRoll = 0f, currentYaw = 0f, currentPitch = 0f;
private float sinTheta = 0f;
private List<int> targetingWeaponIdxList;
// Input calculation variables
private Vector3 desiredHeadingFlat = Vector3.zero;
private float desiredHeadingFlatMagnitude = 0f;
private Vector3 desiredHeadingLocalSpace = Vector3.zero;
private Vector3 desiredHeadingLocalSpaceXZPlane = Vector3.zero;
private Vector3 desiredUpLocalSpace = Vector3.zero;
private Vector3 desiredUpLocalSpaceXYPlane = Vector3.zero;
private Vector3 desiredUpLocalSpaceYZPlane = Vector3.zero;
private Vector3 shipForwardFlat = Vector3.zero;
private Vector3 desiredLocalVelocity = Vector3.zero;
private Vector3 currentLocalVelocity = Vector3.zero;
// Characteristics of the ship
// Physical characteristics
private float shipMaxFlightTurnAcceleration = 100f;
private float shipMaxGroundTurnAcceleration = 100f;
private float shipMaxAngularAcceleration = 100f;
private float shipMaxBrakingConstantDecelerationZ = 100f;
private float shipMaxBrakingEffectiveDragCoefficientZ = 0f;
private float shipMaxBrakingConstantDecelerationX = 100f;
private float shipMaxBrakingConstantDecelerationY = 100f;
// Combat characteristics
private float primaryFireProjectileSpeed = 0f;
private float secondaryFireProjectileSpeed = 0f;
private float primaryFireProjectileDespawnTime = 0f;
private float secondaryFireProjectileDespawnTime = 0f;
private bool primaryFireUsesTurrets = false;
private bool secondaryFireUsesTurrets = false;
private Vector3 primaryFireWeaponDirection = Vector3.forward;
private Vector3 secondaryFireWeaponDirection = Vector3.forward;
private Vector3 primaryFireWeaponRelativePosition = Vector3.zero;
private Vector3 secondaryFireWeaponRelativePosition = Vector3.zero;
#if UNITY_EDITOR
private bool logStateNullWarning = true;
#endif
#endregion
// Use this for initialization
void Awake()
{
if (initialiseOnAwake) { Initialise(); }
}
#region Update Methods
// Update is called once per frame
void Update()
{
// Only do any calculations if we have initialised and the ship is enabled
if (isInitialised && shipControlModule.ShipIsEnabled())
{
// Clear behaviour inputs list
for (int i = 0; i < behavioursListCount; i++) { behaviourInputsList[i].ClearBehaviourInput(); }
// Update position and movement data (so that all data is current)
shipControlModule.shipInstance.UpdatePositionAndMovementData(transform, shipControlModule.ShipRigidbody);
#region Calculate Combined Behaviour Input
// Call state method to get prioritised list of behaviour inputs
// First check that current state and callback method are not null
if (currentState != null && currentState.callbackStateMethod != null)
{
// Update state method parameters
stateMethodParameters.targetPosition = targetPosition;
stateMethodParameters.targetRotation = targetRotation;
stateMethodParameters.targetLocation = targetLocation;
stateMethodParameters.targetPath = targetPath;
stateMethodParameters.targetShip = targetShip;
stateMethodParameters.shipsToEvade = shipsToEvade;
stateMethodParameters.surfaceTurretsToEvade = surfaceTurretsToEvade;
stateMethodParameters.targetRadius = targetRadius;
stateMethodParameters.targetDistance = targetDistance;
stateMethodParameters.targetAngularDistance = targetAngularDistance;
stateMethodParameters.targetVelocity = targetVelocity;
stateMethodParameters.targetTime = targetTime;
// Call state method
currentState.callbackStateMethod(stateMethodParameters);
#if UNITY_EDITOR
// Reset logging condition
logStateNullWarning = true;
#endif
}
#if UNITY_EDITOR
else if (currentState == null)
{
if (logStateNullWarning)
{
Debug.LogWarning("ERROR: AI state is null on " + gameObject.name + ". Make sure that when calling " +
"SetState() you pass in a valid state ID.");
logStateNullWarning = false;
}
}
else
{
if (logStateNullWarning)
{
Debug.LogWarning("ERROR: AI state method is null on " + gameObject.name + ". If you are using a custom state, " +
"make sure to set the callbackStateMethod to the custom state method you have written.");
logStateNullWarning = false;
}
}
#endif
// Combine behaviour inputs
CombineBehaviourInputs(combinedBehaviourOutput, behaviourInputsList, behaviourOutputsList,
shipControlModule.shipInstance.TransformPosition, shipControlModule.shipInstance.WorldVelocity);
// If the target (the actual world-space position the behaviour output is aiming for) is set, remember
// it as the new latest target
if (combinedBehaviourOutput.setTarget)
{
lastBehaviourInputTarget = combinedBehaviourOutput.target;
}
// If the current state action has been completed, call the relevant callback (if it has been assigned)
if (hasCompletedStateAction && callbackCompletedStateAction != null)
{
callbackCompletedStateAction(this);
}
#endregion
#region Calculate Ship Input
#region Rotational Input
// Calculate data common to the different algorithms
// In the future, 2D algorithms may not use all of this data, so may need to split it up
// Create flattened equivalent of combinedBehaviourOutput.heading
desiredHeadingFlat = combinedBehaviourOutput.heading;
desiredHeadingFlat.y = 0f;
desiredHeadingFlatMagnitude = desiredHeadingFlat.magnitude;
// We divide by this later, so we need to make sure this is non-zero
if (desiredHeadingFlatMagnitude < 0.01f) { desiredHeadingFlatMagnitude = 0.01f; }
// Check whether an up direction was specified
bool upDirectionSpecified = combinedBehaviourOutput.up.sqrMagnitude > 0.01f;
// Calculate desired up direction in local space
if (movementAlgorithm == AIMovementAlgorithm.PlanarFlight || movementAlgorithm == AIMovementAlgorithm.PlanarFlightBanking)
{
// Desired up for planar flight is world up direction
desiredUpLocalSpace = shipControlModule.shipInstance.TransformInverseRotation * Vector3.up;
// Calculate desired up projected into XY and YZ planes
desiredUpLocalSpaceXYPlane = desiredUpLocalSpace;
desiredUpLocalSpaceXYPlane.z = 0f;
desiredUpLocalSpaceYZPlane = desiredUpLocalSpace;
desiredUpLocalSpaceYZPlane.x = 0f;
// Normalise vectors
desiredUpLocalSpace.Normalize();
desiredUpLocalSpaceXYPlane.Normalize();
desiredUpLocalSpaceYZPlane.Normalize();
}
else if (movementAlgorithm == AIMovementAlgorithm.Full3DFlight)
{
// For full 3D flight we want to turn in the following manner:
// - Roll so that the current heading is "up" or "down" in local space (not to the left or to the right)
// - Then pitch to match the current heading
// - The two actions above are performed simultaneously, but an "up" direction for the ship is calculated
// as if they would be performed one after the other
// First, transform heading into ship local space
desiredHeadingLocalSpace = shipControlModule.shipInstance.TransformInverseRotation * combinedBehaviourOutput.heading;
if (!upDirectionSpecified)
{
// No up direction provided, so calculate it based on heading
// Project heading onto local XY plane by removing z component
// This will become the desired up projected into the XY plane
desiredUpLocalSpaceXYPlane = desiredHeadingLocalSpace;
desiredUpLocalSpaceXYPlane.z = 0f;
// Then minus the component of the XY-projected vector in the direction of the original heading
// to calculate desired up direction
desiredUpLocalSpace = desiredUpLocalSpaceXYPlane - (desiredHeadingLocalSpace * Vector3.Dot(desiredHeadingLocalSpace, desiredUpLocalSpaceXYPlane));
// Calculate desired up projected into YZ plane
desiredUpLocalSpaceYZPlane = desiredUpLocalSpace;
desiredUpLocalSpaceYZPlane.x = 0f;
// The above calculation for the desired up direction will always produce an up direction such that the
// target is above the ship (in terms of pitch angle). This is usually desirable, but sometimes the
// target will be just a small angle below the ship, which would require the ship to roll 180 degrees to meet
// the target. So the code below allows the up direction to be flipped if the following conditions are met:
// 1. The desired heading is below the ship
if (desiredHeadingLocalSpace.y < 0f)
{
desiredUpLocalSpace *= -1f;
desiredUpLocalSpaceXYPlane *= -1f;
desiredUpLocalSpaceYZPlane *= -1f;
}
}
else
{
// Up direction was provided, so use that
desiredUpLocalSpace = shipControlModule.shipInstance.TransformInverseRotation * combinedBehaviourOutput.up;
// Project into local XY and YZ planes
desiredUpLocalSpaceXYPlane = desiredUpLocalSpace;
desiredUpLocalSpaceXYPlane.z = 0f;
desiredUpLocalSpaceYZPlane = desiredUpLocalSpace;
desiredUpLocalSpaceYZPlane.x = 0f;
}
// Normalise up direction vectors
desiredUpLocalSpace.Normalize();
desiredUpLocalSpaceXYPlane.Normalize();
desiredUpLocalSpaceYZPlane.Normalize();
// Calculate desired heading projected into XZ plane
// TODO: Originally this wasn't normalised - but I think it should be
// I need to check what effect it has
desiredHeadingLocalSpaceXZPlane = desiredHeadingLocalSpace;
desiredHeadingLocalSpaceXZPlane.y = 0f;
desiredHeadingLocalSpaceXZPlane.Normalize();
}
// Calculate a flattened version of the ship forwards vector
shipForwardFlat = shipControlModule.shipInstance.TransformForward;
shipForwardFlat.y = 0f;
if (movementAlgorithm == AIMovementAlgorithm.PlanarFlight || movementAlgorithm == AIMovementAlgorithm.PlanarFlightBanking)
{
// Ship pitch calculations
// Calculate the sine of the pitch delta angle between our current up direction and our desired up direction
sinTheta = Vector3.Cross(desiredUpLocalSpaceYZPlane, Vector3.up).x;
// Clamp sinTheta between -1 and 1
if (sinTheta > 1f) { sinTheta = 1f; }
else if (sinTheta < -1f) { sinTheta = -1f; }
// Use arcsin to determine the actual angle
currentPitch = Mathf.Asin(sinTheta) * Mathf.Rad2Deg;
// Target pitch is based on y-value of desired heading
targetPitch = Mathf.Atan(-combinedBehaviourOutput.heading.y / desiredHeadingFlatMagnitude) * Mathf.Rad2Deg;
// Limit the pitch to within the provided constraints
if (targetPitch < -maxPitchAngle) { targetPitch = -maxPitchAngle; }
else if (targetPitch > maxPitchAngle) { targetPitch = maxPitchAngle; }
// Ship yaw calculations
// Calculate the sine of the yaw delta angle between our desired forward direction and our current forward direction
sinTheta = Vector3.Cross(desiredHeadingFlat / desiredHeadingFlatMagnitude, shipForwardFlat).y;
// Clamp sinTheta between -1 and 1
if (sinTheta > 1f) { sinTheta = 1f; }
else if (sinTheta < -1f) { sinTheta = -1f; }
// Use arcsin to determine the actual angle
currentYaw = Mathf.Asin(sinTheta) * Mathf.Rad2Deg;
// If heading is in opposite direction to ship forwards, adjust angle (as arcsine will give wrong angle)
if (Vector3.Dot(desiredHeadingFlat, shipForwardFlat) < 0f)
{
currentYaw = currentYaw > 0f ? 180f - currentYaw : currentYaw - 180f;
}
// Target yaw is zero (as it is measured relative to the desired pitch)
targetYaw = 0f;
// Calculate the sine of the roll delta angle between our current up direction and our desired up direction
sinTheta = Vector3.Cross(Vector3.up, desiredUpLocalSpaceXYPlane).z;
// Clamp sinTheta between -1 and 1
if (sinTheta > 1f) { sinTheta = 1f; }
else if (sinTheta < -1f) { sinTheta = -1f; }
// Use arcsin to determine the actual angle
currentRoll = Mathf.Asin(sinTheta) * Mathf.Rad2Deg;
if (movementAlgorithm == AIMovementAlgorithm.PlanarFlight)
{
// Target roll is zero (as it is measured relative to the desired pitch)
targetRoll = 0f;
}
else if (movementAlgorithm == AIMovementAlgorithm.PlanarFlightBanking)
{
// Target roll delta should be based on our current yaw
//targetRoll = -currentYaw * 0.2f;
targetRoll = (-currentYaw / maxBankTurnAngle) * maxBankAngle;
if (targetRoll < -maxBankAngle) { targetRoll = -maxBankAngle; }
else if (targetRoll > maxBankAngle) { targetRoll = maxBankAngle; }
}
}
else
{
// Only do yaw calculations if there is some bias towards yaw,
// OR if we have a specified up direction (since then we will want to yaw no matter what)
if (upDirectionSpecified || rollBias < 1f)
{
// Calculate the sine of the yaw delta angle between our current forward direction and our desired forward direction
sinTheta = Vector3.Cross(desiredHeadingLocalSpaceXZPlane, Vector3.forward).y;
// Clamp sinTheta between -1 and 1
if (sinTheta > 1f) { sinTheta = 1f; }
else if (sinTheta < -1f) { sinTheta = -1f; }
// Use arcsin to determine the actual angle
currentYaw = Mathf.Asin(sinTheta) * Mathf.Rad2Deg;
// If heading is in opposite direction to ship forwards, adjust angle (as arcsine will give wrong angle)
if (desiredHeadingLocalSpaceXZPlane.z < 0f)
{
currentYaw = currentYaw > 0f ? 180f - currentYaw : -180f - currentYaw;
}
}
// Target yaw is zero (as it is measured relative to the desired yaw)
targetYaw = 0f;
// Only do roll calculations if there is some bias towards roll,
// OR if we have a specified up direction (since then we will want to roll no matter what)
if (upDirectionSpecified || rollBias > 0f)
{
// Calculate the sine of the roll delta angle between our current up direction and our desired up direction
sinTheta = Vector3.Cross(Vector3.up, desiredUpLocalSpaceXYPlane).z;
// Clamp sinTheta between -1 and 1
if (sinTheta > 1f) { sinTheta = 1f; }
else if (sinTheta < -1f) { sinTheta = -1f; }
// Use arcsin to determine the actual angle
currentRoll = Mathf.Asin(sinTheta) * Mathf.Rad2Deg;
// If up direction is in opposite direction to ship upwards, adjust angle (as arcsine will give wrong angle)
if (desiredUpLocalSpaceXYPlane.y < 0f)
{
currentRoll = currentRoll > 0f ? 180f - currentRoll : -180f - currentRoll;
}
}
// Target roll is zero (as it is measured relative to the desired pitch)
targetRoll = 0f;
// Decide whether we will use pitch to steer (this is only needed if we have no specified up direction)
// Here we will also choose whether we will use roll or yaw to steer with (we only want to use one at a time
// when there is no specified up direction)
bool usePitchToSteer = true;
if (!upDirectionSpecified)
{
// Bias: 0-1: 0 = full yaw, 1 = full roll, 0.5 = no bias
bool chooseRollToSteer = false;
float currentTurningValue = 0f;
// If roll bias is zero, always choose yaw to steer with
if (rollBias < 0.001f) { chooseRollToSteer = false; }
// If roll bias is one, always choose roll to steer with
else if (rollBias > 0.999f) { chooseRollToSteer = true; }
else
{
// Otherwise, calculate a bias value
float KValue = 0.082085f * Mathf.Exp(5f * rollBias);
// Choose roll or yaw: Whichever has the shortest angle to turn through
// (adjusted by roll bias)
if (Mathf.Abs(currentYaw) * KValue > Mathf.Abs(currentRoll)) { chooseRollToSteer = true; }
else { chooseRollToSteer = false; }
}
// Roll was chosen to steer with
if (chooseRollToSteer) { currentYaw = 0f; currentTurningValue = currentRoll; }
// Yaw was chosen to steer with
else { currentRoll = 0f; currentTurningValue = currentYaw; }
// Only use pitch to steer when we are within turnPitchThreshold degrees of the correct yaw/roll angle
usePitchToSteer = currentTurningValue > -turnPitchThreshold && currentTurningValue < turnPitchThreshold;
}
// Only use pitch to steer when we are within turnPitchThreshold degrees of the correct yaw/roll angle
// OR if we have a specified up direction (since then we will want to pitch no matter what)
if (usePitchToSteer)
{
// Ship pitch calculations
// Calculate the sine of the pitch delta angle between our current up direction and our desired up direction
sinTheta = Vector3.Cross(desiredUpLocalSpaceYZPlane, Vector3.up).x;
// Clamp sinTheta between -1 and 1
if (sinTheta > 1f) { sinTheta = 1f; }
else if (sinTheta < -1f) { sinTheta = -1f; }
// Use arcsin to determine the actual angle
currentPitch = Mathf.Asin(sinTheta) * Mathf.Rad2Deg;
// If the up direction is in opposite direction to ship upwards, adjust angle (as arcsine will give wrong angle)
if (desiredUpLocalSpaceYZPlane.y < 0f)
{
currentPitch = currentPitch > 0f ? 180f - currentPitch : -180f - currentPitch;
}
// If the heading is in opposite direction to forwards, and we have no specified up direction
// OR if the up direction is in opposite direction to ship upwards, and we have a specified up direction,
// flip pitch 180 degrees. This is because:
// - If we have no specified up direction (we auto-generated one) and the heading is behind us,
// we actually need to flip over with pitch in order to go in the correct direction
// - If we have a specified up direction and the up direction is below us, we want to use roll
// instead of pitch to achieve the desired up direction. So we need to flip the pitch,
// since it will be flipped again once we complete the roll.
if ((desiredHeadingLocalSpace.z < 0f && !upDirectionSpecified) ||
(desiredUpLocalSpaceYZPlane.y < 0f && upDirectionSpecified))
{
// Adding 180 degrees is because we always want to pitch up not down
currentPitch = currentPitch > 0f ? currentPitch - 180f : currentPitch + 180f;
}
// OLD CODE
//// Otherwise, if the up direction is in opposite direction to ship upwards, and we have
//// a specified up direction, adjust angle (as arcsine will give wrong angle)
//if (desiredUpLocalSpaceYZPlane.y < 0f && upDirectionSpecified)
//{
// // Something new to try... adjust angle first!
// currentPitch = currentPitch > 0f ? 180f - currentPitch : -180f - currentPitch;
// // CURRENT BEST
// currentPitch = currentPitch > 0f ? currentPitch - 180f : currentPitch + 180f;
//}
// Target pitch is zero (as it is measured relative to the desired pitch)
targetPitch = 0f;
}
else
{
currentPitch = 0f;
targetPitch = 0f;
}
}
// Always calculate yaw input from PID controller
shipInput.yaw = yawPIDController.RequiredInput(targetYaw, currentYaw, Time.deltaTime);
if (shipControlModule.shipInstance.IsGrounded)
{
// If ship is grounded, set pitch and roll input to zero
shipInput.pitch = 0f;
shipInput.roll = 0f;
}
else
{
// If ship isn't grounded, calculate pitch and roll input from PID controllers
shipInput.pitch = pitchPIDController.RequiredInput(targetPitch, currentPitch, Time.deltaTime);
shipInput.roll = rollPIDController.RequiredInput(targetRoll, currentRoll, Time.deltaTime);
}
#endregion
#region Translational Input
// Transform steering vectors into local space
desiredLocalVelocity = shipControlModule.shipInstance.TransformInverseRotation * combinedBehaviourOutput.velocity;
currentLocalVelocity = shipControlModule.shipInstance.TransformInverseRotation * shipControlModule.shipInstance.WorldVelocity;
shipInput.horizontal = horizontalPIDController.RequiredInput(desiredLocalVelocity.x, currentLocalVelocity.x, Time.deltaTime);
shipInput.vertical = verticalPIDController.RequiredInput(desiredLocalVelocity.y, currentLocalVelocity.y, Time.deltaTime);
shipInput.longitudinal = longitudinalPIDController.RequiredInput(desiredLocalVelocity.z, currentLocalVelocity.z, Time.deltaTime);
#endregion
#region Weapons Input
// TODO remove when satisfied
//// Only fire if there is a target, it is in range and within the fire angle
//if (targetShip != null && IsTargetInRange())
//{
// shipInput.primaryFire = Mathf.Abs(currentYaw - targetYaw) < fireAngle && Mathf.Abs(currentPitch - targetPitch) < fireAngle;
// shipInput.secondaryFire = shipInput.primaryFire;
//}
//else
//{
// shipInput.primaryFire = false;
// shipInput.secondaryFire = false;
//}
// Default - don't fire
shipInput.primaryFire = false;
shipInput.secondaryFire = false;
// Only fire if there is a target
if (targetShip != null)
{
Vector3 weaponFirePosition = Vector3.zero;
Vector3 weaponFireVelocity = Vector3.forward;
// Check if we fired the primary weapon if it would hit the target ship
weaponFirePosition = shipControlModule.shipInstance.TransformPosition +
(shipControlModule.shipInstance.TransformRotation * primaryFireWeaponRelativePosition);
// If using turrets, always fire
if (primaryFireUsesTurrets)
{
shipInput.primaryFire = true;
}
// If not using turrets, projectiles will be fired from weapon direction
else
{
weaponFireVelocity = (shipControlModule.shipInstance.TransformRotation * primaryFireWeaponDirection) * primaryFireProjectileSpeed;
// TODO ship radius - how do we get this for the other ship?
// (currently just uses 5 * radius of our ship)
shipInput.primaryFire = AIBehaviourInput.OnCollisionCourse(shipControlModule.shipInstance.TransformPosition,
shipControlModule.shipInstance.WorldVelocity + weaponFireVelocity, 0f, targetShip.TransformPosition,
targetShip.WorldVelocity, shipRadius * 5f, primaryFireProjectileDespawnTime);
}
// Check if we fired the secondary weapon if it would hit the target ship
weaponFirePosition = shipControlModule.shipInstance.TransformPosition +
(shipControlModule.shipInstance.TransformRotation * secondaryFireWeaponRelativePosition);
// If using turrets, always fire
if (secondaryFireUsesTurrets)
{
shipInput.secondaryFire = true;
}
// If not using turrets, projectiles will be fired from weapon direction
else
{
weaponFireVelocity = (shipControlModule.shipInstance.TransformRotation * secondaryFireWeaponDirection) * secondaryFireProjectileSpeed;
// TODO ship radius - how do we get this for the other ship?
// (currently just uses 5 * radius of our ship)
shipInput.secondaryFire = AIBehaviourInput.OnCollisionCourse(shipControlModule.shipInstance.TransformPosition,
shipControlModule.shipInstance.WorldVelocity + weaponFireVelocity, 0f, targetShip.TransformPosition,
targetShip.WorldVelocity, shipRadius * 5f, secondaryFireProjectileDespawnTime);
}
}
// Strafing run with target as a position
if (currentState.id == AIState.strafingRunStateID)
{
Vector3 weaponFirePosition = Vector3.zero;
Vector3 weaponFireVelocity = Vector3.forward;
// Check if we fired the primary weapon if it would hit the target
weaponFirePosition = shipControlModule.shipInstance.TransformPosition +
(shipControlModule.shipInstance.TransformRotation * primaryFireWeaponRelativePosition);
// If using turrets, always fire
if (primaryFireUsesTurrets)
{
shipInput.primaryFire = true;
}
// If not using turrets, projectiles will be fired from weapon direction
else
{
weaponFireVelocity = (shipControlModule.shipInstance.TransformRotation * primaryFireWeaponDirection) * primaryFireProjectileSpeed;
// TODO target radius - how do we get this for the target?
// (currently just uses 5 * radius of our ship)
shipInput.primaryFire = AIBehaviourInput.OnCollisionCourse(shipControlModule.shipInstance.TransformPosition,
shipControlModule.shipInstance.WorldVelocity + weaponFireVelocity, 0f, targetPosition,
Vector3.zero, shipRadius * 5f, primaryFireProjectileDespawnTime);
}
// Check if we fired the secondary weapon if it would hit the target
weaponFirePosition = shipControlModule.shipInstance.TransformPosition +
(shipControlModule.shipInstance.TransformRotation * secondaryFireWeaponRelativePosition);
// If using turrets, always fire
if (secondaryFireUsesTurrets)
{
shipInput.secondaryFire = true;
}
// If not using turrets, projectiles will be fired from weapon direction
else
{
weaponFireVelocity = (shipControlModule.shipInstance.TransformRotation * secondaryFireWeaponDirection) * secondaryFireProjectileSpeed;
// TODO target radius - how do we get this for the target?
// (currently just uses 5 * radius of our ship)
shipInput.secondaryFire = AIBehaviourInput.OnCollisionCourse(shipControlModule.shipInstance.TransformPosition,
shipControlModule.shipInstance.WorldVelocity + weaponFireVelocity, 0f, targetPosition,
Vector3.zero, shipRadius * 5f, secondaryFireProjectileDespawnTime);
}
}
#endregion
#endregion
#region Send Calculated Ship Input
// Send the calculated input to the ship
shipControlModule.SendInput(shipInput);
#endregion
}
}
#endregion
#region Private Methods
#region Old Steering Wander Behaviour
///// <summary>
///// Adds a weighted desired steering/heading from the "wander" behaviour.
///// </summary>
///// <param name="targetPosition"></param>
///// <param name="desiredHeadingVector"></param>
///// <param name="desiredUpVector"></param>
///// <param name="steeringVector"></param>
///// <param name="behaviourWeighting"></param>
//private void AddWander(float wanderStrength, float wanderRate, ref Vector3 desiredHeadingVector, ref Vector3 desiredUpVector,
// ref Vector3 steeringVector, float behaviourWeighting)
//{
// currentWanderDirection += UnityEngine.Random.onUnitSphere * wanderRate * Time.deltaTime;
// currentWanderDirection *= wanderStrength / currentWanderDirection.magnitude;
// headingVector = shipControlModule.shipInstance.TransformRotation * currentWanderDirection;
// headingVector += 10f * shipControlModule.shipInstance.TransformForward;
// // Desired heading is towards the target position
// headingVectorNormalised = headingVector.normalized;
// desiredHeadingVector += headingVectorNormalised * behaviourWeighting;
// // No desired upwards orientation
// // Steering vector is desired velocity minus current velocity, desired velocity is in the direction of desired heading
// //steeringVector += ((maxSpeed * headingVectorNormalised) - shipControlModule.shipInstance.WorldVelocity) * behaviourWeighting;
// steeringVector += headingVectorNormalised * 10f * behaviourWeighting;
//}
#endregion
#region Set Behaviour
/// <summary>
/// Sets an AIBehaviourOutput using a specified AIBehaviourInput. If the resulting AIBehaviourOutput has
/// use targeting accuracy enabled, will apply targeting accuracy to the heading.
/// </summary>
/// <param name="aiBehaviourInput"></param>
/// <param name="aiBehaviourOutput"></param>
private void SetBehaviourOutput(AIBehaviourInput aiBehaviourInput, AIBehaviourOutput aiBehaviourOutput)
{
switch (aiBehaviourInput.behaviourType)
{
case AIBehaviourInput.AIBehaviourType.Idle:
AIBehaviourInput.SetIdleBehaviourOutput(aiBehaviourInput, aiBehaviourOutput);
break;
case AIBehaviourInput.AIBehaviourType.Seek:
AIBehaviourInput.SetSeekBehaviourOutput(aiBehaviourInput, aiBehaviourOutput);
break;
case AIBehaviourInput.AIBehaviourType.Flee:
AIBehaviourInput.SetFleeBehaviourOutput(aiBehaviourInput, aiBehaviourOutput);
break;
case AIBehaviourInput.AIBehaviourType.Pursuit:
AIBehaviourInput.SetPursuitBehaviourOutput(aiBehaviourInput, aiBehaviourOutput);
break;
case AIBehaviourInput.AIBehaviourType.Evasion:
AIBehaviourInput.SetEvasionBehaviourOutput(aiBehaviourInput, aiBehaviourOutput);
break;
case AIBehaviourInput.AIBehaviourType.SeekArrival:
AIBehaviourInput.SetSeekArrivalBehaviourOutput(aiBehaviourInput, aiBehaviourOutput);
break;
case AIBehaviourInput.AIBehaviourType.SeekMovingArrival:
AIBehaviourInput.SetSeekMovingArrivalBehaviourOutput(aiBehaviourInput, aiBehaviourOutput);
break;
case AIBehaviourInput.AIBehaviourType.PursuitArrival:
AIBehaviourInput.SetPursuitArrivalBehaviourOutput(aiBehaviourInput, aiBehaviourOutput);
break;
//case AIBehaviourInput.AIBehaviourType.Follow:
// AIBehaviourInput.SetFollowInputBehaviour(aiBehaviourInput);
// break;
//case AIBehaviourInput.AIBehaviourType.Avoid:
// AIBehaviourInput.SetAvoidInputBehaviour(aiBehaviourInput);
// break;
case AIBehaviourInput.AIBehaviourType.UnblockCylinder:
AIBehaviourInput.SetUnblockCylinderBehaviourOutput(aiBehaviourInput, aiBehaviourOutput);
break;
case AIBehaviourInput.AIBehaviourType.UnblockCone:
AIBehaviourInput.SetUnblockConeBehaviourOutput(aiBehaviourInput, aiBehaviourOutput);
break;
case AIBehaviourInput.AIBehaviourType.ObstacleAvoidance:
AIBehaviourInput.SetObstacleAvoidanceBehaviourOutput(aiBehaviourInput, aiBehaviourOutput);
break;
case AIBehaviourInput.AIBehaviourType.FollowPath:
AIBehaviourInput.SetFollowPathBehaviourOutput(aiBehaviourInput, aiBehaviourOutput);
break;
case AIBehaviourInput.AIBehaviourType.Dock:
AIBehaviourInput.SetDockBehaviourOutput(aiBehaviourInput, aiBehaviourOutput);
break;
case AIBehaviourInput.AIBehaviourType.CustomIdle:
if (callbackCustomIdleBehaviour != null) { callbackCustomIdleBehaviour(aiBehaviourInput, aiBehaviourOutput); }
else { AIBehaviourInput.SetIdleBehaviourOutput(aiBehaviourInput, aiBehaviourOutput); }
break;
case AIBehaviourInput.AIBehaviourType.CustomSeek:
if (callbackCustomSeekBehaviour != null) { callbackCustomSeekBehaviour(aiBehaviourInput, aiBehaviourOutput); }
else { AIBehaviourInput.SetSeekBehaviourOutput(aiBehaviourInput, aiBehaviourOutput); }
break;
case AIBehaviourInput.AIBehaviourType.CustomFlee:
if (callbackCustomFleeBehaviour != null) { callbackCustomFleeBehaviour(aiBehaviourInput, aiBehaviourOutput); }
else { AIBehaviourInput.SetFleeBehaviourOutput(aiBehaviourInput, aiBehaviourOutput); }
break;
case AIBehaviourInput.AIBehaviourType.CustomPursuit:
if (callbackCustomPursuitBehaviour != null) { callbackCustomPursuitBehaviour(aiBehaviourInput, aiBehaviourOutput); }
else { AIBehaviourInput.SetPursuitBehaviourOutput(aiBehaviourInput, aiBehaviourOutput); }
break;
case AIBehaviourInput.AIBehaviourType.CustomEvasion:
if (callbackCustomEvasionBehaviour != null) { callbackCustomEvasionBehaviour(aiBehaviourInput, aiBehaviourOutput); }
else { AIBehaviourInput.SetEvasionBehaviourOutput(aiBehaviourInput, aiBehaviourOutput); }
break;
case AIBehaviourInput.AIBehaviourType.CustomSeekArrival:
if (callbackCustomSeekArrivalBehaviour != null) { callbackCustomSeekArrivalBehaviour(aiBehaviourInput, aiBehaviourOutput); }
else { AIBehaviourInput.SetSeekArrivalBehaviourOutput(aiBehaviourInput, aiBehaviourOutput); }
break;
case AIBehaviourInput.AIBehaviourType.CustomSeekMovingArrival:
if (callbackCustomSeekMovingArrivalBehaviour != null) { callbackCustomSeekMovingArrivalBehaviour(aiBehaviourInput, aiBehaviourOutput); }
else { AIBehaviourInput.SetSeekMovingArrivalBehaviourOutput(aiBehaviourInput, aiBehaviourOutput); }
break;
case AIBehaviourInput.AIBehaviourType.CustomPursuitArrival:
if (callbackCustomPursuitArrivalBehaviour != null) { callbackCustomPursuitArrivalBehaviour(aiBehaviourInput, aiBehaviourOutput); }
else { AIBehaviourInput.SetPursuitArrivalBehaviourOutput(aiBehaviourInput, aiBehaviourOutput); }
break;
//case AIBehaviourInput.AIBehaviourType.CustomFollow:
// if (callbackCustomFollowBehaviour != null) { callbackCustomFollowBehaviour(aiBehaviourInput); }
// else { AIBehaviourInput.SetFollowInputBehaviour(aiBehaviourInput); }
// break;
//case AIBehaviourInput.AIBehaviourType.CustomAvoid:
// if (callbackCustomAvoidBehaviour != null) { callbackCustomAvoidBehaviour(aiBehaviourInput); }
// else { AIBehaviourInput.SetAvoidInputBehaviour(aiBehaviourInput); }
// break;
case AIBehaviourInput.AIBehaviourType.CustomUnblockCylinder:
if (callbackCustomUnblockCylinderBehaviour != null) { callbackCustomUnblockCylinderBehaviour(aiBehaviourInput, aiBehaviourOutput); }
else { AIBehaviourInput.SetUnblockCylinderBehaviourOutput(aiBehaviourInput, aiBehaviourOutput); }
break;
case AIBehaviourInput.AIBehaviourType.CustomUnblockCone:
if (callbackCustomUnblockConeBehaviour != null) { callbackCustomUnblockConeBehaviour(aiBehaviourInput, aiBehaviourOutput); }
else { AIBehaviourInput.SetUnblockConeBehaviourOutput(aiBehaviourInput, aiBehaviourOutput); }
break;
case AIBehaviourInput.AIBehaviourType.CustomObstacleAvoidance:
if (callbackCustomObstacleAvoidanceBehaviour != null) { callbackCustomObstacleAvoidanceBehaviour(aiBehaviourInput, aiBehaviourOutput); }
else { AIBehaviourInput.SetObstacleAvoidanceBehaviourOutput(aiBehaviourInput, aiBehaviourOutput); }
break;
case AIBehaviourInput.AIBehaviourType.CustomFollowPath:
if (callbackCustomFollowPathBehaviour != null) { callbackCustomFollowPathBehaviour(aiBehaviourInput, aiBehaviourOutput); }
else { AIBehaviourInput.SetFollowPathBehaviourOutput(aiBehaviourInput, aiBehaviourOutput); }
break;
case AIBehaviourInput.AIBehaviourType.CustomDock:
if (callbackCustomDockBehaviour != null) { callbackCustomDockBehaviour(aiBehaviourInput, aiBehaviourOutput); }
else { AIBehaviourInput.SetDockBehaviourOutput(aiBehaviourInput, aiBehaviourOutput); }
break;
default:
AIBehaviourInput.SetIdleBehaviourOutput(aiBehaviourInput, aiBehaviourOutput);
break;
}
// If the resulting AIBehaviourOutput has use targeting accuracy enabled, apply it to the heading
if (aiBehaviourOutput.useTargetingAccuracy && targetingAccuracy < 1f)
{
// Calculate maximum amount of deviation using target accuracy
float maxHeadingDeviation = (1f - targetingAccuracy) * 0.1f;
// Generate two vectors perpendicular to the heading vector
// TODO would like to ensure continuity - maybe do some check of x and z components of heading?
Vector3 perpendicularV1 = Vector3.Cross(aiBehaviourOutput.heading, Vector3.up);
Vector3 perpendicularV2 = Vector3.Cross(aiBehaviourOutput.heading, perpendicularV1);
// Get the current game time
float currentGameTime = Time.time;
// Use the game time to generate two multipliers for the perpendicular components using sine functions
// TODO want to choose better mathematical functions. Aim is:
// 1. Maximise seeming randomness of movement
// 2. Allow the components to both reach zero simultaneously at irregular intervals
float v1Component = maxHeadingDeviation * Mathf.Sin(currentGameTime);
float v2Component = maxHeadingDeviation * Mathf.Sin(currentGameTime * 1.13f);
// Add components to heading
aiBehaviourOutput.heading += (perpendicularV1 * v1Component) + (perpendicularV2 * v2Component);
// Re-normalise heading
aiBehaviourOutput.heading.Normalize();
}
}
#endregion
#region Combine Behaviour Inputs
/// <summary>
/// Combines a list of behaviour inputs into a single output, calculating each output in turn.
/// </summary>
/// <param name="combinedBehaviourOutput"></param>
/// <param name="behaviourInputs"></param>
/// <param name="behaviourOutputs"></param>
/// <param name="shipWorldPosition"></param>
/// <param name="shipWorldVelocity"></param>
public void CombineBehaviourInputs (AIBehaviourOutput combinedBehaviourOutput, List<AIBehaviourInput> behaviourInputs,
List<AIBehaviourOutput> behaviourOutputs, Vector3 shipWorldPosition, Vector3 shipWorldVelocity)
{
// Reset the combined input to a "blank" behaviour input
combinedBehaviourOutput.heading = Vector3.zero;
combinedBehaviourOutput.up = Vector3.zero;
combinedBehaviourOutput.velocity = Vector3.zero;
combinedBehaviourOutput.target = Vector3.zero;
combinedBehaviourOutput.setTarget = true;
// If the currentState is not set, get out quickly
if (currentState == null) { return; }
// TODO - REMOVE TEST CODE - for NaN desiredLocalVelocity
//float tempvalue = 0f;
//int lastBhIdx = -1;
// Loop through behaviour inputs list
AIBehaviourInput behaviourInput;
AIBehaviourOutput behaviourOutput;
float totalWeighting = 0f;
for (int i = 0; i < behavioursListCount; i++)
{
// Get the current behaviour input and output
behaviourInput = behaviourInputs[i];
behaviourOutput = behaviourOutputs[i];
// Only calculate behaviours that have a non-zero weighting
if (behaviourInput.weighting > 0f)
{
// Calculate behaviour output
SetBehaviourOutput(behaviourInput, behaviourOutput);
// Only use behaviours that have a non-zero output
if (behaviourOutput.heading.sqrMagnitude > 0.01f)
{
// TEST CODE for NaN desiredLocalVelocity
//tempvalue += bh.headingOutput.sqrMagnitude;
//lastBhIdx = i;
if (currentState.behaviourCombiner == AIState.BehaviourCombiner.PriorityOnly)
{
// Priority only - first non-zero behaviour is set as the output
combinedBehaviourOutput.heading = behaviourOutput.heading;
combinedBehaviourOutput.up = behaviourOutput.up;
combinedBehaviourOutput.velocity = behaviourOutput.velocity;
combinedBehaviourOutput.target = behaviourOutput.target;
combinedBehaviourOutput.setTarget = behaviourOutput.setTarget;
// Skip all the rest of the behaviours
i = behavioursListCount;
}
else if (currentState.behaviourCombiner == AIState.BehaviourCombiner.PrioritisedDithering)
{
// Prioritised dithering - first non-zero behaviour allowed by probability check is set as the output
// TODO: Should probably add another parameter (dither probability) instead of just repurposing weighting
if (UnityEngine.Random.Range(0f, 1f) < behaviourInput.weighting)
{
combinedBehaviourOutput.heading = behaviourOutput.heading;
combinedBehaviourOutput.up = behaviourOutput.up;
combinedBehaviourOutput.velocity = behaviourOutput.velocity;
combinedBehaviourOutput.target = behaviourOutput.target;
combinedBehaviourOutput.setTarget = behaviourOutput.setTarget;
// Skip all the rest of the behaviours
i = behavioursListCount;
}
}
else
{
// Weighted average - output is set as weighted average of all non-zero behaviours
// Add weighted heading and up vectors to total
combinedBehaviourOutput.heading += behaviourOutput.heading * behaviourInput.weighting;
combinedBehaviourOutput.up += behaviourOutput.up * behaviourInput.weighting;
// Add weighted velocity delta to total
combinedBehaviourOutput.velocity += (behaviourOutput.velocity - shipWorldVelocity) * behaviourInput.weighting;
// Add weighted target delta to total
combinedBehaviourOutput.target += (behaviourOutput.target - shipWorldPosition) * behaviourInput.weighting;
// Add weighting to total
totalWeighting += behaviourInput.weighting;
}
}
}
}
//TEST CODE TO CHECK for NaN on desiredLocalVelocity
//if (combinedBehaviourInput.velocityOutput == Vector3.zero)
//{
// //if (lastBhIdx == 3)
// //{
// // bh = behaviourInputs[3];
// // Debug.Log("[DEBUG] NaN alert on " + gameObject.name + " targetVelocity:" + bh.targetVelocity + " velocityOutput:" + bh.velocityOutput + " headingOutput:" + bh.headingOutput + " btype: " + bh.behaviourType);
// //}
// Debug.Log("[DEBUG] NaN alert on " + gameObject.name + " tempvalue: " + tempvalue + ", velocityOutput: " + combinedBehaviourInput.velocityOutput + " combiner: " + currentState.behaviourCombiner + " lastBhIdx: " + lastBhIdx);
//}
if (currentState.behaviourCombiner == AIState.BehaviourCombiner.WeightedAverage &&
totalWeighting > 0f)
{
// Divide totals by total weighting
combinedBehaviourOutput.heading /= totalWeighting;
combinedBehaviourOutput.up /= totalWeighting;
combinedBehaviourOutput.velocity /= totalWeighting;
// Add ship world velocity back to behaviour input velocity
combinedBehaviourOutput.velocity += shipWorldVelocity;
// Add ship world position back to behaviour input target
combinedBehaviourOutput.target += shipWorldPosition;
combinedBehaviourOutput.setTarget = false;
// Normalise inputs
combinedBehaviourOutput.NormaliseOutputs();
}
}
#endregion
#region Target Methods
/// <summary>
/// Sets a list of weapons that can be assigned a target. This should be called
/// if weapon characterists of the ship are changed at runtime. The weapon position
/// in the ship weaponList are cached in a reusable list to save on GC and improve
/// performance.
/// </summary>
private void SetTargetingWeaponList()
{
if (shipControlModule != null && shipControlModule.shipInstance != null)
{
int numWeapons = shipControlModule.shipInstance.weaponList == null ? 0 : shipControlModule.shipInstance.weaponList.Count;
if (targetingWeaponIdxList == null) { targetingWeaponIdxList = new List<int>(numWeapons); }
else { targetingWeaponIdxList.Clear(); }
Weapon weapon = null;
if (targetingWeaponIdxList != null)
{
for (int wpIdx = 0; wpIdx < numWeapons; wpIdx++)
{
weapon = shipControlModule.shipInstance.weaponList[wpIdx];
if (weapon != null)
{
// Does this look like a weapon that can be assigned a target? (i.e. is it a turret or does
// it use guided projectiles, and also does it not have auto targeting enabled, which overrides everything)
if (((weapon.weaponType == Weapon.WeaponType.TurretProjectile && weapon.turretPivotY != null && weapon.turretPivotX != null)
|| weapon.isProjectileKGuideToTarget) && weapon.projectilePrefab != null && !weapon.isAutoTargetingEnabled)
{
targetingWeaponIdxList.Add(wpIdx);
}
}
}
}
}
}
#endregion
#endregion
#region Public Member API Methods
#region Initialisation / Precalculation API Methods
/// <summary>
/// Initialises the Ship AI Input Module.
/// </summary>
public void Initialise()
{
// Don't run if already initialised.
if (isInitialised) { return; }
// Find the ship control module that we will send input to
shipControlModule = GetComponent<ShipControlModule>();
// If the ship control module has not been initialised yet, initialise it
shipControlModule.InitialiseShip();
// Create a new ShipInput instance
shipInput = new ShipInput();
// Initialise PID controllers
pitchPIDController = new PIDController(0.05f, 0f, 0.025f);
pitchPIDController.SetInputLimits(-1f, 1f);
yawPIDController = new PIDController(0.05f, 0f, 0.025f);
yawPIDController.SetInputLimits(-1f, 1f);
rollPIDController = new PIDController(0.05f, 0f, 0.025f);
rollPIDController.SetInputLimits(-1f, 1f);
verticalPIDController = new PIDController(0.1f, 0.05f, 0f);
verticalPIDController.SetInputLimits(-1f, 1f);
horizontalPIDController = new PIDController(0.1f, 0.05f, 0f);
horizontalPIDController.SetInputLimits(-1f, 1f);
longitudinalPIDController = new PIDController(1f, 0.05f, 0f);
longitudinalPIDController.SetInputLimits(-1f, 1f);
SetTargetingWeaponList();
// Set up behaviour inputs and outputs
behaviourInputsList = new List<AIBehaviourInput>(behavioursListCount);
behaviourOutputsList = new List<AIBehaviourOutput>(behavioursListCount);
for (int i = 0; i < behavioursListCount; i++)
{
behaviourInputsList.Add(new AIBehaviourInput(shipControlModule, this));
behaviourOutputsList.Add(new AIBehaviourOutput());
}
combinedBehaviourOutput = new AIBehaviourOutput();
// Initialise AI State data if it hasn't already been initialised
AIState.Initialise();
// Set initial AI state to Idle
SetState(AIState.idleStateID);
// Initialise state method parameters with behaviour inputs list and our ship
stateMethodParameters = new AIStateMethodParameters(behaviourInputsList, shipControlModule, this);
// Recalculate ship parameters
RecalculateShipParameters();
ReinitialiseDiscardData();
isInitialised = true;
}
/// <summary>
/// Recalculates the parameters for the AI's "model" of the ship. Should be called if any of the ship's characteristics
/// are modified.
/// </summary>
public void RecalculateShipParameters ()
{
#region Calculate Movement Parameters
if (shipControlModule.shipInstance.shipPhysicsModel == Ship.ShipPhysicsModel.Arcade)
{
#region Arcade
// Max turning acceleration is based on max flight and ground turning acceleration
shipMaxFlightTurnAcceleration = shipControlModule.shipInstance.arcadeMaxFlightTurningAcceleration;
shipMaxGroundTurnAcceleration = shipControlModule.shipInstance.arcadeMaxGroundTurningAcceleration;
// Max angular acceleration is based on arcade yaw and pitch acceleration
// Currently I just use the minimum of the two accelerations
//shipMaxAngularAcceleration = (shipControlModule.shipInstance.arcadeYawAcceleration +
// shipControlModule.shipInstance.arcadePitchAcceleration) * 0.375f;
shipMaxAngularAcceleration = shipControlModule.shipInstance.arcadeYawAcceleration < shipControlModule.shipInstance.arcadePitchAcceleration ?
shipControlModule.shipInstance.arcadeYawAcceleration : shipControlModule.shipInstance.arcadePitchAcceleration;
// Max braking constant deceleration is based on thrusters and arcade brake min acceleration
shipMaxBrakingConstantDecelerationX = 0f;
shipMaxBrakingConstantDecelerationY = 0f;
shipMaxBrakingConstantDecelerationZ = 0f;
// Loop through the list of thrusters
int thrusterListCount = shipControlModule.shipInstance.thrusterList.Count;
Thruster thrusterComponent;
int LRTurningThrustersCount = 0;
int UDTurningThrustersCount = 0;
float LRTurningThrust = 0f;
float UDTurningThrust = 0f;
float upBrakingThrust = 0f;
float downBrakingThrust = 0f;
float rightBrakingThrust = 0f;
float leftBrakingThrust = 0f;
for (int thrusterIndex = 0; thrusterIndex < thrusterListCount; thrusterIndex++)
{
thrusterComponent = shipControlModule.shipInstance.thrusterList[thrusterIndex];
// Find any braking thrusters
if (thrusterComponent.forceUse == 2)
{
shipMaxBrakingConstantDecelerationZ += thrusterComponent.maxThrust *
-thrusterComponent.thrustDirectionNormalised.z / shipControlModule.shipInstance.mass;
}
// Find any up/down turning thrusters
else if (thrusterComponent.forceUse == 3)
{
// Up thruster
UDTurningThrust += thrusterComponent.maxThrust * thrusterComponent.thrustDirectionNormalised.y;
UDTurningThrustersCount++;
// Up thrusters can be used to brake on Y axis
upBrakingThrust += thrusterComponent.maxThrust * thrusterComponent.thrustDirectionNormalised.y;
}
else if (thrusterComponent.forceUse == 4)
{
// Down thruster
UDTurningThrust += thrusterComponent.maxThrust * -thrusterComponent.thrustDirectionNormalised.y;
UDTurningThrustersCount++;
// Down thrusters can be used to brake on Y axis
downBrakingThrust += thrusterComponent.maxThrust * -thrusterComponent.thrustDirectionNormalised.y;
}
// Find any left/right turning thrusters
else if (thrusterComponent.forceUse == 5)
{
// Right thruster
LRTurningThrust += thrusterComponent.maxThrust * thrusterComponent.thrustDirectionNormalised.x;
LRTurningThrustersCount++;
// Right thrusters can be used to brake on X axis
rightBrakingThrust += thrusterComponent.maxThrust * thrusterComponent.thrustDirectionNormalised.x;
}
else if (thrusterComponent.forceUse == 6)
{
// Left thruster
LRTurningThrust += thrusterComponent.maxThrust * -thrusterComponent.thrustDirectionNormalised.x;
LRTurningThrustersCount++;
// Left thrusters can be used to brake on X axis
rightBrakingThrust += thrusterComponent.maxThrust * -thrusterComponent.thrustDirectionNormalised.x;
}
}
// Max braking constant deceleration X is taken from the minimum braking force in each direction
if (rightBrakingThrust >= leftBrakingThrust)
{
shipMaxBrakingConstantDecelerationX = rightBrakingThrust / shipControlModule.shipInstance.mass;
}
else
{
shipMaxBrakingConstantDecelerationX = leftBrakingThrust / shipControlModule.shipInstance.mass;
}
// Max braking constant deceleration Y is taken from the minimum braking force in each direction
if (upBrakingThrust >= downBrakingThrust)
{
shipMaxBrakingConstantDecelerationY = upBrakingThrust / shipControlModule.shipInstance.mass;
}
else
{
shipMaxBrakingConstantDecelerationY = downBrakingThrust / shipControlModule.shipInstance.mass;
}
// Max braking effective drag coefficient is based on arcade brake strength
if (shipControlModule.shipInstance.arcadeUseBrakeComponent)
{
shipMaxBrakingConstantDecelerationZ += shipControlModule.shipInstance.arcadeBrakeMinAcceleration;
shipMaxBrakingEffectiveDragCoefficientZ = shipControlModule.shipInstance.arcadeBrakeStrength * 0.5f;
if (!shipControlModule.shipInstance.arcadeBrakeIgnoreMediumDensity)
{
shipMaxBrakingEffectiveDragCoefficientZ *= shipControlModule.shipInstance.mediumDensity;
}
// Need to divide drag coefficient by mass to get acceleration
shipMaxBrakingEffectiveDragCoefficientZ /= shipControlModule.shipInstance.mass;
}
else { shipMaxBrakingEffectiveDragCoefficientZ = 0f; }
// Add any up/down/left/right turning thrust found to flight turn acceleration
if (UDTurningThrustersCount + LRTurningThrustersCount > 0)
{
shipMaxFlightTurnAcceleration += ((UDTurningThrust + LRTurningThrust) /
(UDTurningThrustersCount + LRTurningThrustersCount)) / shipControlModule.shipInstance.mass;
}
// Add any left/right turning thrust found to ground turn acceleration
if (UDTurningThrustersCount > 0)
{
shipMaxGroundTurnAcceleration += (LRTurningThrust / LRTurningThrustersCount) / shipControlModule.shipInstance.mass;
}
// Make sure flight and ground turn accelerations are a minimum of 50 m/s^2
if (shipMaxFlightTurnAcceleration < 50f) { shipMaxFlightTurnAcceleration = 50f; }
if (shipMaxGroundTurnAcceleration < 50f) { shipMaxGroundTurnAcceleration = 50f; }
#endregion
}
else
{
#region Physics-Based
// TODO: will probably be able to calculate the following parameters
// (shipMaxFlightTurnAcceleration, shipMaxGroundTurnAcceleration, shipMaxAngularAcceleration)
// more accurately after we have done the physics-based update
// shipMaxBrakingConstantDeceleration, shipMaxBrakingEffectiveDragCoefficient are probably correct already though
// Loop through the list of thrusters
int thrusterListCount = shipControlModule.shipInstance.thrusterList.Count;
Thruster thrusterComponent;
shipMaxBrakingConstantDecelerationX = 0f;
shipMaxBrakingConstantDecelerationY = 0f;
shipMaxBrakingConstantDecelerationZ = 0f;
float shipMaxVerticalAcceleration = 0f;
float shipMaxHorizontalAcceleration = 0f;
float shipMaxPitchAngularAcceleration = 0f;
float shipMaxYawAngularAcceleration = 0f;
float shipMaxRollAngularAcceleration = 0f;
float shipAveragePitchThrottleTime = 0f;
float shipAverageYawThrottleTime = 0f;
float shipAverageRollThrottleTime = 0f;
float upBrakingThrust = 0f;
float downBrakingThrust = 0f;
float rightBrakingThrust = 0f;
float leftBrakingThrust = 0f;
for (int thrusterIndex = 0; thrusterIndex < thrusterListCount; thrusterIndex++)
{
thrusterComponent = shipControlModule.shipInstance.thrusterList[thrusterIndex];
// Max braking constant deceleration is based on reverse thrusters
if (thrusterComponent.forceUse == 2)
{
shipMaxBrakingConstantDecelerationZ += thrusterComponent.maxThrust *
-thrusterComponent.thrustDirectionNormalised.z / shipControlModule.shipInstance.mass;
}
else if (thrusterComponent.forceUse == 3)
{
shipMaxVerticalAcceleration += thrusterComponent.maxThrust *
thrusterComponent.thrustDirectionNormalised.y / shipControlModule.shipInstance.mass;
// Up thrusters can be used to brake on Y axis
upBrakingThrust += thrusterComponent.maxThrust * thrusterComponent.thrustDirectionNormalised.y;
}
else if (thrusterComponent.forceUse == 4)
{
shipMaxVerticalAcceleration += thrusterComponent.maxThrust *
-thrusterComponent.thrustDirectionNormalised.y / shipControlModule.shipInstance.mass;
// Down thrusters can be used to brake on Y axis
downBrakingThrust += thrusterComponent.maxThrust * -thrusterComponent.thrustDirectionNormalised.y;
}
else if (thrusterComponent.forceUse == 5)
{
shipMaxHorizontalAcceleration += thrusterComponent.maxThrust *
thrusterComponent.thrustDirectionNormalised.x / shipControlModule.shipInstance.mass;
// Right thrusters can be used to brake on X axis
rightBrakingThrust += thrusterComponent.maxThrust * thrusterComponent.thrustDirectionNormalised.x;
}
else if (thrusterComponent.forceUse == 6)
{
shipMaxHorizontalAcceleration += thrusterComponent.maxThrust *
-thrusterComponent.thrustDirectionNormalised.x / shipControlModule.shipInstance.mass;
// Left thrusters can be used to brake on X axis
leftBrakingThrust += thrusterComponent.maxThrust * -thrusterComponent.thrustDirectionNormalised.x;
}
// The thruster angular acceleration is equal to the torque caused by this thurster divided by the moment of inertia on this axis
Vector3 thrusterAngularAcceleration = Vector3.Cross(thrusterComponent.relativePosition - shipControlModule.shipInstance.centreOfMass,
thrusterComponent.maxThrust * thrusterComponent.thrustDirectionNormalised) /
Mathf.Abs(Vector3.Dot(shipControlModule.ShipRigidbody.inertiaTensor, thrusterComponent.thrustDirectionNormalised));
// Pitch thrusters
if (thrusterComponent.primaryMomentUse == 3 || thrusterComponent.secondaryMomentUse == 3)
{
shipMaxPitchAngularAcceleration += thrusterAngularAcceleration.x;
// Weight the average throttle time by the angular acceleration of the thruster
shipAveragePitchThrottleTime += (thrusterComponent.rampUpDuration > thrusterComponent.rampDownDuration ?
thrusterComponent.rampUpDuration : thrusterComponent.rampDownDuration) * thrusterAngularAcceleration.x;
}
else if (thrusterComponent.primaryMomentUse == 4 || thrusterComponent.secondaryMomentUse == 4)
{
shipMaxPitchAngularAcceleration -= thrusterAngularAcceleration.x;
// Weight the average throttle time by the angular acceleration of the thruster
shipAveragePitchThrottleTime += (thrusterComponent.rampUpDuration > thrusterComponent.rampDownDuration ?
thrusterComponent.rampUpDuration : thrusterComponent.rampDownDuration) * -thrusterAngularAcceleration.x;
}
// Yaw thrusters
if (thrusterComponent.primaryMomentUse == 5 || thrusterComponent.secondaryMomentUse == 5)
{
shipMaxYawAngularAcceleration += thrusterAngularAcceleration.y;
// Weight the average throttle time by the angular acceleration of the thruster
shipAverageYawThrottleTime += (thrusterComponent.rampUpDuration > thrusterComponent.rampDownDuration ?
thrusterComponent.rampUpDuration : thrusterComponent.rampDownDuration) * thrusterAngularAcceleration.y;
}
else if (thrusterComponent.primaryMomentUse == 6 || thrusterComponent.secondaryMomentUse == 6)
{
shipMaxYawAngularAcceleration -= thrusterAngularAcceleration.y;
// Weight the average throttle time by the angular acceleration of the thruster
shipAverageYawThrottleTime += (thrusterComponent.rampUpDuration > thrusterComponent.rampDownDuration ?
thrusterComponent.rampUpDuration : thrusterComponent.rampDownDuration) * -thrusterAngularAcceleration.y;
}
// Roll thrusters
if (thrusterComponent.primaryMomentUse == 1 || thrusterComponent.secondaryMomentUse == 1)
{
shipMaxRollAngularAcceleration -= thrusterAngularAcceleration.z;
// Weight the average throttle time by the angular acceleration of the thruster
shipAverageRollThrottleTime += (thrusterComponent.rampUpDuration > thrusterComponent.rampDownDuration ?
thrusterComponent.rampUpDuration : thrusterComponent.rampDownDuration) * -thrusterAngularAcceleration.z;
}
else if (thrusterComponent.primaryMomentUse == 2 || thrusterComponent.secondaryMomentUse == 2)
{
shipMaxRollAngularAcceleration += thrusterAngularAcceleration.z;
// Weight the average throttle time by the angular acceleration of the thruster
shipAverageRollThrottleTime += (thrusterComponent.rampUpDuration > thrusterComponent.rampDownDuration ?
thrusterComponent.rampUpDuration : thrusterComponent.rampDownDuration) * thrusterAngularAcceleration.z;
}
}
// Angular accelerations need to be scaled by the allocated pitch/roll/yaw power
shipMaxPitchAngularAcceleration *= shipControlModule.shipInstance.pitchPower;
shipMaxRollAngularAcceleration *= shipControlModule.shipInstance.rollPower;
shipMaxYawAngularAcceleration *= shipControlModule.shipInstance.yawPower;
// Max flight turn acceleration is based on left/right/up/down thrusters
// Max ground turn acceleration is based on left/right thrusters
shipMaxFlightTurnAcceleration = (shipMaxHorizontalAcceleration + shipMaxVerticalAcceleration) * 0.5f;
shipMaxGroundTurnAcceleration = shipMaxHorizontalAcceleration;
// Max angular acceleration is based on pitch and yaw thrusters
// Currently I just use the minimum of the two accelerations
//shipMaxAngularAcceleration = (shipMaxPitchAngularAcceleration + shipMaxYawAngularAcceleration) * 0.375f;
shipMaxAngularAcceleration = shipMaxPitchAngularAcceleration < shipMaxYawAngularAcceleration ?
shipMaxPitchAngularAcceleration : shipMaxYawAngularAcceleration;
// Calculate average throttle up/down time for thrusters on each rotational axis
if (shipMaxPitchAngularAcceleration > 0f) { shipAveragePitchThrottleTime /= shipMaxPitchAngularAcceleration; }
if (shipMaxYawAngularAcceleration > 0f) { shipAverageYawThrottleTime /= shipMaxYawAngularAcceleration; }
if (shipMaxRollAngularAcceleration > 0f) { shipAverageRollThrottleTime /= shipMaxRollAngularAcceleration; }
// Set individual input limits for the PID rotation controllers
pitchPIDController.useIndividualInputLimits = true;
pitchPIDController.SetIndividualInputLimits(-1f, 1f, -1f, 1f, -2f, 2f);
yawPIDController.useIndividualInputLimits = true;
yawPIDController.SetIndividualInputLimits(-1f, 1f, -1f, 1f, -2f, 2f);
rollPIDController.useIndividualInputLimits = true;
rollPIDController.SetIndividualInputLimits(-1f, 1f, -1f, 1f, -2f, 2f);
// Calculate proportional derivative parameters for the PID rotation controllers
pitchPIDController.pGain = 0.05f;
pitchPIDController.dGain = 2f * Mathf.Sqrt(pitchPIDController.pGain * 0.5f / shipMaxPitchAngularAcceleration) *
(1f + shipAveragePitchThrottleTime);
yawPIDController.pGain = 0.05f;
yawPIDController.dGain = 2f * Mathf.Sqrt(yawPIDController.pGain * 0.5f / shipMaxYawAngularAcceleration) *
(1f + shipAverageYawThrottleTime);
rollPIDController.pGain = 0.05f;
rollPIDController.dGain = 2f * Mathf.Sqrt(rollPIDController.pGain * 0.5f / shipMaxRollAngularAcceleration) *
(1f + shipAverageRollThrottleTime);
//Debug.Log("Pitch... P-Gain set to " + pitchPIDController.pGain.ToString("0.0000") + ". D-Gain set to " + pitchPIDController.dGain.ToString("0.0000"));
//Debug.Log("Roll.... P-Gain set to " + rollPIDController.pGain.ToString("0.0000") + ". D-Gain set to " + rollPIDController.dGain.ToString("0.0000"));
//Debug.Log("Yaw..... P-Gain set to " + yawPIDController.pGain.ToString("0.0000") + ". D-Gain set to " + yawPIDController.dGain.ToString("0.0000"));
// Max braking constant deceleration X is taken from the minimum braking force in each direction
if (rightBrakingThrust >= leftBrakingThrust)
{
shipMaxBrakingConstantDecelerationX = rightBrakingThrust / shipControlModule.shipInstance.mass;
}
else
{
shipMaxBrakingConstantDecelerationX = leftBrakingThrust / shipControlModule.shipInstance.mass;
}
// Max braking constant deceleration Y is taken from the minimum braking force in each direction
if (upBrakingThrust >= downBrakingThrust)
{
shipMaxBrakingConstantDecelerationY = upBrakingThrust / shipControlModule.shipInstance.mass;
}
else
{
shipMaxBrakingConstantDecelerationY = downBrakingThrust / shipControlModule.shipInstance.mass;
}
// Max braking effective drag coefficient is based on air brake control surfaces
shipMaxBrakingEffectiveDragCoefficientZ = 0f;
// Loop through the list of control surfaces
int controlSurfaceListCount = shipControlModule.shipInstance.controlSurfaceList.Count;
ControlSurface controlSurfaceComponent;
for (int controlSurfaceIndex = 0; controlSurfaceIndex < controlSurfaceListCount; controlSurfaceIndex++)
{
controlSurfaceComponent = shipControlModule.shipInstance.controlSurfaceList[controlSurfaceIndex];
if (controlSurfaceComponent.type == ControlSurface.ControlSurfaceType.AirBrake)
{
shipMaxBrakingEffectiveDragCoefficientZ += 0.5f * shipControlModule.shipInstance.mediumDensity *
controlSurfaceComponent.chord * controlSurfaceComponent.span * 2f / shipControlModule.shipInstance.mass;
}
}
#endregion
}
#endregion
#region Calculate Combat Parameters
// Set some default values in case no relevant weapons are found
primaryFireProjectileSpeed = 0f;
primaryFireProjectileDespawnTime = 0f;
primaryFireUsesTurrets = false;
secondaryFireProjectileSpeed = 0f;
secondaryFireProjectileDespawnTime = 0f;
secondaryFireUsesTurrets = false;
// Loop through the list of weapons
int weaponListCount = shipControlModule.shipInstance.weaponList.Count;
Weapon weaponComponent;
ProjectileModule weaponProjectilePrefab;
for (int weaponIndex = 0; weaponIndex < weaponListCount; weaponIndex++)
{
weaponComponent = shipControlModule.shipInstance.weaponList[weaponIndex];
// Check that the weapon has a valid projectile prefab
weaponProjectilePrefab = weaponComponent.projectilePrefab;
if (weaponProjectilePrefab != null)
{
if (weaponComponent.firingButton == Weapon.FiringButton.Primary)
{
// Primary fire input weapons
// We want to find the weapon with the fastest projectile speed
if (weaponProjectilePrefab.startSpeed > primaryFireProjectileSpeed)
{
primaryFireProjectileSpeed = weaponProjectilePrefab.startSpeed;
primaryFireProjectileDespawnTime = weaponProjectilePrefab.despawnTime;
primaryFireUsesTurrets = weaponComponent.weaponType == Weapon.WeaponType.TurretProjectile;
primaryFireWeaponDirection = weaponComponent.fireDirectionNormalised;
primaryFireWeaponRelativePosition = weaponComponent.relativePosition;
}
}
else if (weaponComponent.firingButton == Weapon.FiringButton.Secondary)
{
// Seconday fire input weapons
// We want to find the weapon with the fastest projectile speed
if (weaponProjectilePrefab.startSpeed > secondaryFireProjectileSpeed)
{
secondaryFireProjectileSpeed = weaponProjectilePrefab.startSpeed;
secondaryFireProjectileDespawnTime = weaponProjectilePrefab.despawnTime;
secondaryFireUsesTurrets = weaponComponent.weaponType == Weapon.WeaponType.TurretProjectile;
secondaryFireWeaponDirection = weaponComponent.fireDirectionNormalised;
secondaryFireWeaponRelativePosition = weaponComponent.relativePosition;
}
}
}
}
#endregion
}
/// <summary>
/// Resets the ship's PID Controllers. Call this if you manually modify the ship's velocity or angular velocity.
/// </summary>
public void ResetPIDControllers ()
{
// Reset all PID controllers
pitchPIDController.ResetController();
yawPIDController.ResetController();
rollPIDController.ResetController();
verticalPIDController.ResetController();
horizontalPIDController.ResetController();
longitudinalPIDController.ResetController();
}
#endregion
#region Physics API Methods
/// <summary>
/// Calculates the maxmimum speed for a ship along a curve.
/// </summary>
/// <param name="curveStartingRadius"></param>
/// <param name="curveEndingRadius"></param>
/// <param name="curveLength"></param>
/// <returns></returns>
public float MaxSpeedAlongCurve (float curveStartingRadius, float curveEndingRadius, float curveLength, bool isGrounded)
{
// Calculate the limiting speed based on maximum centripetal acceleration
float curveStartSpeed = MaxSpeedAlongConstantRadiusCurve(curveStartingRadius, isGrounded);
float curveEndSpeed = MaxSpeedAlongConstantRadiusCurve(curveEndingRadius, isGrounded);
// Take into account the time we have to slow down before the middle of the curve
curveEndSpeed = MaxSpeedFromBrakingDistance(curveEndSpeed, curveLength * 0.5f, Vector3.forward);
// Take the minimum of curve start and end speeds as the limiting speed based on maximum centripetal acceleration
float accelerationLimitedSpeed = curveStartSpeed < curveEndSpeed ? curveStartSpeed : curveEndSpeed;
// Calculate the limiting speed based on maximum angular acceleration
float angularAccelerationLimitedSpeed = Mathf.Infinity;
// Only calculate an angular acceleration limited speed if the starting and ending radii are different
// Otherwise there would be no need for any angular acceleration
if (curveStartingRadius != curveEndingRadius)
{
angularAccelerationLimitedSpeed = MaxSpeedAlongChangingRadiusCurve(curveStartingRadius, curveEndingRadius, curveLength);
}
// Return the minimum value of acceleration limited and angular acceleration limited speeds
return accelerationLimitedSpeed < angularAccelerationLimitedSpeed ? accelerationLimitedSpeed : angularAccelerationLimitedSpeed;
}
/// <summary>
/// Calculates the maximum speed for a ship along a curve of constant radius.
/// </summary>
/// <param name="curveRadius"></param>
/// <returns></returns>
public float MaxSpeedAlongConstantRadiusCurve (float curveRadius, bool isGrounded)
{
// Calculate the limiting speed based on maximum centripetal acceleration
return isGrounded ? (float)System.Math.Sqrt(shipMaxGroundTurnAcceleration * curveRadius) : (float)System.Math.Sqrt(shipMaxFlightTurnAcceleration * curveRadius);
}
/// <summary>
/// Calculates the maximum speed for a ship along a curve of changing radius.
/// </summary>
/// <param name="curveStartingRadius"></param>
/// <param name="curveEndingRadius"></param>
/// <param name="curveLength"></param>
/// <returns></returns>
public float MaxSpeedAlongChangingRadiusCurve (float curveStartingRadius, float curveEndingRadius, float curveLength)
{
// Avoid possible divide by zero errors
if (curveStartingRadius < 0.01f) { curveStartingRadius = 0.01f; }
if (curveEndingRadius < 0.01f) { curveEndingRadius = 0.01f; }
// Assumes that the velocity through the curve remains constant, and calculates the maximum this velocity
// can be given the maximum angular acceleration of the ship
float squareVelocity = (curveStartingRadius * shipMaxAngularAcceleration * Mathf.Deg2Rad * curveLength) / ((curveStartingRadius / curveEndingRadius) - 1f);
return Mathf.Sqrt(squareVelocity > 0f ? squareVelocity : -squareVelocity);
}
/// <summary>
/// Calculates the maximum current speed for a ship given a target speed at a target distance away from its current position,
/// along a particular (normalised) local velocity direction.
/// </summary>
/// <param name="targetSpeed"></param>
/// <param name="targetDistance"></param>
/// <param name="localVeloDir">Must be normalised!</param>
/// <returns></returns>
public float MaxSpeedFromBrakingDistance (float targetSpeed, float targetDistance, Vector3 localVeloDir)
{
// Calculate braking constant deceleration weighted by movement direction
float shipMaxBrakingConstantDeceleration =
(localVeloDir.x > 0f ? localVeloDir.x : -localVeloDir.x) * shipMaxBrakingConstantDecelerationX +
(localVeloDir.y > 0f ? localVeloDir.y : -localVeloDir.y) * shipMaxBrakingConstantDecelerationY +
(localVeloDir.z > 0f ? localVeloDir.z : -localVeloDir.z) * shipMaxBrakingConstantDecelerationZ;
if (localVeloDir.sqrMagnitude < Mathf.Epsilon)
{
// If the ship is not moving, there will no movement direction vector, so weight all of the braking
// direction components equally (0.578 = 1/sqrt(3))
shipMaxBrakingConstantDeceleration = 0.578f *
(shipMaxBrakingConstantDecelerationX + shipMaxBrakingConstantDecelerationY + shipMaxBrakingConstantDecelerationZ);
}
// Calculate braking effective drag coefficient weighted by movement direction
float shipMaxBrakingEffectiveDragCoefficient =
(localVeloDir.z > 0f ? localVeloDir.z : -localVeloDir.z) * shipMaxBrakingEffectiveDragCoefficientZ;
if (shipMaxBrakingEffectiveDragCoefficient > 0f) // Test code for 1.2.7 Beta 3a+ to avoid div by 0 error (NaN result)
{
// When shipMaxBrakingEffectiveDragCoefficient = 0, then below results in a NaN due to div by 0 error.
// u = sqrt((e^(2*d*cd) * (a + cd*v^2) - a) / cd)
return (float)System.Math.Sqrt(((float)System.Math.Exp(2f * targetDistance * shipMaxBrakingEffectiveDragCoefficient) *
(shipMaxBrakingConstantDeceleration + (shipMaxBrakingEffectiveDragCoefficient * targetSpeed * targetSpeed)) -
shipMaxBrakingConstantDeceleration) / shipMaxBrakingEffectiveDragCoefficient);
}
else
{
// v^2 - u^2 = 2*a*d => u = sqrt(v^2 - 2*a*d)
// NOTE: 2*a*d is positive in the code as deceleration is the negative of acceleration
//return (float)System.Math.Sqrt((targetSpeed * targetSpeed) + (2f * shipMaxBrakingConstantDeceleration * targetDistance));
float _maxSpeed = (float)System.Math.Sqrt((targetSpeed * targetSpeed) + (2f * shipMaxBrakingConstantDeceleration * targetDistance));
if (_maxSpeed == 0f && targetDistance > 0.001f)
{
Debug.LogWarning("ERROR MaxSpeedFromBrakingDistance - targetSpeed: " + targetSpeed + " targetDistance: " + targetDistance + " shipMaxBrakingConstantDeceleration: " + shipMaxBrakingConstantDeceleration + " on " + transform.name + " T:" + Time.time);
//Debug.LogWarning("X: " + shipMaxBrakingConstantDecelerationX + " Y: " + shipMaxBrakingConstantDecelerationY + " Z: " + shipMaxBrakingConstantDecelerationZ);
return 1f;
}
else { return _maxSpeed; }
}
}
/// <summary>
/// Calculates the distance required to slow down from the current speed to the target speed,
/// along a particular (normalised) local velocity direction.
/// </summary>
/// <param name="currentSpeed"></param>
/// <param name="targetSpeed"></param>
/// <param name="localVeloDir">Must be normalised!</param>
/// <returns></returns>
public float BrakingDistance (float currentSpeed, float targetSpeed, Vector3 localVeloDir)
{
// Calculate braking constant deceleration weighted by movement direction
float shipMaxBrakingConstantDeceleration =
(localVeloDir.x > 0f ? localVeloDir.x : -localVeloDir.x) * shipMaxBrakingConstantDecelerationX +
(localVeloDir.y > 0f ? localVeloDir.y : -localVeloDir.y) * shipMaxBrakingConstantDecelerationY +
(localVeloDir.z > 0f ? localVeloDir.z : -localVeloDir.z) * shipMaxBrakingConstantDecelerationZ;
// Potentially this should be using localVeloDir.sqrMagnitude < Mathf.Epsilon
if (localVeloDir == Vector3.zero)
{
// If the ship is not moving, there will no movement direction vector, so weight all of the braking
// direction components equally (0.578 = 1/sqrt(3))
shipMaxBrakingConstantDeceleration = 0.578f *
(shipMaxBrakingConstantDecelerationX + shipMaxBrakingConstantDecelerationY + shipMaxBrakingConstantDecelerationZ);
}
// Calculate braking effective drag coefficient weighted by movement direction
float shipMaxBrakingEffectiveDragCoefficient =
(localVeloDir.z > 0f ? localVeloDir.z : -localVeloDir.z) * shipMaxBrakingEffectiveDragCoefficientZ;
if (shipMaxBrakingEffectiveDragCoefficient > 0f)
{
// d = ln((a + cd*u^2)/(a + cd*v^2)) / (2 * cd)
return (float)System.Math.Log((shipMaxBrakingConstantDeceleration + shipMaxBrakingEffectiveDragCoefficient * currentSpeed * currentSpeed) /
(shipMaxBrakingConstantDeceleration + shipMaxBrakingEffectiveDragCoefficient * targetSpeed * targetSpeed)) /
(2f * shipMaxBrakingEffectiveDragCoefficient);
}
else
{
// v^2 - u^2 = 2*a*d => d = (v^2 - u^2) / (2*a)
return (currentSpeed * currentSpeed - targetSpeed * targetSpeed) / (2f * shipMaxBrakingConstantDeceleration);
}
}
#endregion
#region Behaviour Input Information API Methods
/// <summary>
/// Returns the last position to be designated as the target position by the chosen AI behaviour input.
/// </summary>
/// <returns></returns>
public Vector3 GetLastBehaviourInputTarget () { return lastBehaviourInputTarget; }
#endregion
#region Assign API Methods
/// <summary>
/// Assigns a target path for this AI ship, to be used by the current state.
/// Sets the current target path location index to the second point or the first point if there is no second point.
/// </summary>
/// <param name="target"></param>
public void AssignTargetPath (PathData pathData)
{
targetPath = pathData;
// Attempt to set the target path location index
if (pathData != null && pathData.pathLocationDataList != null)
{
prevTargetPathLocationIndex = SSCManager.GetFirstAssignedLocationIdx(pathData);
currentTargetPathLocationIndex = SSCManager.GetNextPathLocationIndex(pathData, prevTargetPathLocationIndex, false);
}
// Set the target location and position to nothing
targetLocation = null;
targetPosition = Vector3.zero;
}
/// <summary>
/// Assigns a target path for this AI ship, to be used by the current state.
/// Set the previous and next locations along the path, and the normalised distance between the two locations
/// where the ship will join the path.
/// </summary>
/// <param name="pathData"></param>
/// <param name="previousPathLocationIndex"></param>
/// <param name="nextPathLocationIndex"></param>
/// <param name="targetPathTValue"></param>
public void AssignTargetPath (PathData pathData, int previousPathLocationIndex, int nextPathLocationIndex, float targetPathTValue)
{
targetPath = pathData;
// Attempt to set the target path location index
if (pathData != null && pathData.pathLocationDataList != null)
{
prevTargetPathLocationIndex = previousPathLocationIndex;
currentTargetPathLocationIndex = nextPathLocationIndex;
currentTargetPathTValue = targetPathTValue;
}
// Set the target location and position to nothing
targetLocation = null;
targetPosition = Vector3.zero;
}
/// <summary>
/// Assigns a target location for this AI ship, to be used by the current state.
/// </summary>
/// <param name="target"></param>
public void AssignTargetLocation(LocationData locationData)
{
targetLocation = locationData;
// Set the target path and position to nothing
targetPath = null;
targetPosition = Vector3.zero;
}
/// <summary>
/// Assigns a target position for this AI ship, to be used by the current state.
/// </summary>
/// <param name="targetPositionVector"></param>
public void AssignTargetPosition (Vector3 targetPositionVector)
{
targetPosition = targetPositionVector;
// Set the target path and location to nothing
targetLocation = null;
targetPath = null;
}
/// <summary>
/// Assigns a target rotation for this AI ship, to be used by the current state.
/// </summary>
/// <param name="targetRotationQuaternion"></param>
public void AssignTargetRotation(Quaternion targetRotationQuaternion)
{
targetRotation = targetRotationQuaternion;
}
/// <summary>
/// Assigns a target ship for this AI ship, to be used by the current state.
/// </summary>
public void AssignTargetShip (ShipControlModule targetShipControlModule)
{
if (targetShipControlModule != null)
{
targetShip = targetShipControlModule.shipInstance;
#if UNITY_EDITOR
if (!targetShipControlModule.IsInitialised)
{
Debug.LogWarning("ShipAIInputModule.AssignTargetShip: Target ship " + targetShipControlModule.gameObject.name +
" being assigned to " + gameObject.name + " is not initialised. Some AI features may not work" +
" as expected.");
}
#endif
// Set any applicable weapons to also target this ship
int numTargettingWeapons = targetingWeaponIdxList == null ? 0 : targetingWeaponIdxList.Count;
for (int wpIdx = 0; wpIdx < numTargettingWeapons; wpIdx++)
{
Weapon weapon = shipControlModule.shipInstance.weaponList[targetingWeaponIdxList[wpIdx]];
if (weapon != null)
{
weapon.SetTargetShip(targetShipControlModule);
//if (targetShipControlModule != null) { weapon.SetTarget(targetShipControlModule.gameObject); }
//else { weapon.SetTarget(null); }
}
}
}
else { targetShip = null; }
}
/// <summary>
/// Assigns a list of ships to evade for this ship, to be used by the current state.
/// </summary>
/// <param name="shipsToEvadeList"></param>
public void AssignShipsToEvade (List<Ship> shipsToEvadeList)
{
// Sets it to a reference of the list
shipsToEvade = shipsToEvadeList;
}
/// <summary>
/// Assigns a list of surface turrets to evade for this ship, to be used by the current state.
/// </summary>
/// <param name="surfaceTurretsToEvadeList"></param>
public void AssignSurfaceTurretsToEvade(List<SurfaceTurretModule> surfaceTurretsToEvadeList)
{
// Sets it to a reference of the list
surfaceTurretsToEvade = surfaceTurretsToEvadeList;
}
/// <summary>
/// Assigns a target radius for this ship, to be used by the current state.
/// </summary>
/// <param name="targetRadius"></param>
public void AssignTargetRadius(float targetRadius)
{
this.targetRadius = targetRadius;
}
/// <summary>
/// Assigns a target distance for this ship, to be used by the current state.
/// </summary>
/// <param name="targetDistance"></param>
public void AssignTargetDistance(float targetDistance)
{
this.targetDistance = targetDistance;
}
/// <summary>
/// Assigns a target angular distance for this ship, to be used by the current state.
/// </summary>
/// <param name="targetAngularDistance"></param>
public void AssignTargetAngularDistance(float targetAngularDistance)
{
this.targetAngularDistance = targetAngularDistance;
}
/// <summary>
/// Assigns a target time for this ship, to be used by the current state.
/// </summary>
/// <param name="targetTime"></param>
public void AssignTargetTime (float targetTime)
{
this.targetTime = targetTime;
}
/// <summary>
/// Assigns a target velocity for this ship, to be used by the current state.
/// </summary>
/// <param name="targetVelocity"></param>
public void AssignTargetVelocity(Vector3 targetVelocity)
{
this.targetVelocity = targetVelocity;
}
/// <summary>
/// Sets the current index of the location of the target path the AI ship will head towards.
/// If the index value has changed, also updates the Previous Target Path Location Index.
/// </summary>
/// <param name="newTargetPathLocationIndex"></param>
public void SetCurrentTargetPathLocationIndex (int newTargetPathLocationIndex)
{
if (newTargetPathLocationIndex != currentTargetPathLocationIndex)
{
prevTargetPathLocationIndex = currentTargetPathLocationIndex;
}
currentTargetPathLocationIndex = newTargetPathLocationIndex;
}
/// <summary>
/// Sets the current index of the location of the target path the AI ship will head towards.
/// If the index value has changed, also update the Previous Target Path Location Index.
/// Also sets the time value between the previous location and the current (next) location.
/// The time value should be between 0.0 and 1.0
/// </summary>
/// <param name="newTargetPathLocationIndex"></param>
/// <param name="newTargetPathLocationTValue"></param>
public void SetCurrentTargetPathLocationIndex(int newTargetPathLocationIndex, float newTargetPathLocationTValue)
{
if (newTargetPathLocationIndex != currentTargetPathLocationIndex)
{
prevTargetPathLocationIndex = currentTargetPathLocationIndex;
}
currentTargetPathLocationIndex = newTargetPathLocationIndex;
currentTargetPathTValue = newTargetPathLocationTValue;
}
/// <summary>
/// Sets the previous index of the location of the target path the AI ship is heading away from.
/// </summary>
/// <param name="newTargetPathLocationIndex"></param>
public void SetPreviousTargetPathLocationIndex(int newTargetPathLocationIndex)
{
prevTargetPathLocationIndex = newTargetPathLocationIndex;
}
/// <summary>
/// Set the time value between the previous Target Path Location
/// and the current (next) Location along the Path. The TValue
/// should be between 0.0 and 1.0.
/// </summary>
/// <param name="tValue"></param>
public void SetCurrentTargetPathTValue(float tValue)
{
currentTargetPathTValue = tValue;
}
/// <summary>
/// Sets the current stage index for the current state. This (zero-based) index is used to keep track of what stage
/// the AI ship has reached in the current state. Typically, this should only be set from inside a state method.
/// </summary>
/// <returns></returns>
public void SetCurrentStateStageIndex(int newStateStageIndex)
{
currentStateStageIndex = newStateStageIndex;
}
#endregion
#region Get Target API Methods
/// <summary>
/// Gets the currently assigned target path (if any).
/// </summary>
/// <returns></returns>
public PathData GetTargetPath()
{
return targetPath;
}
/// <summary>
/// Gets the currently assigned target position (if any).
/// A returned value of Vector3.Zero indicates it is unassigned.
/// </summary>
/// <returns></returns>
public Vector3 GetTargetPosition()
{
return targetPosition;
}
/// <summary>
/// Gets the currently assigned target rotation (if any).
/// </summary>
/// <returns></returns>
public Quaternion GetTargetRotation()
{
return targetRotation;
}
/// <summary>
/// Gets the currently assigned target location (if any).
/// </summary>
/// <returns></returns>
public LocationData GetTargetLocation()
{
return targetLocation;
}
/// <summary>
/// Gets the currently assigned target ship (if any).
/// </summary>
/// <returns></returns>
public Ship GetTargetShip()
{
return targetShip;
}
/// <summary>
/// Gets the currently assigned list of ships to evade (if any).
/// </summary>
/// <returns></returns>
public List<Ship> GetShipsToEvade ()
{
return shipsToEvade;
}
/// <summary>
/// Gets the currently assigned list of surface turrets to evade (if any).
/// </summary>
/// <returns></returns>
public List<SurfaceTurretModule> GetSurfaceTurretsToEvade()
{
return surfaceTurretsToEvade;
}
/// <summary>
/// Gets the currently assigned target radius.
/// </summary>
/// <returns></returns>
public float GetTargetRadius()
{
return targetRadius;
}
/// <summary>
/// Gets the currently assigned target distance.
/// </summary>
/// <returns></returns>
public float GetTargetDistance()
{
return targetDistance;
}
/// <summary>
/// Gets the currently assigned target angular distance.
/// </summary>
/// <returns></returns>
public float GetTargetAngularDistance()
{
return targetAngularDistance;
}
/// <summary>
/// Gets the currently assigned target time.
/// </summary>
/// <returns></returns>
public float GetTargetTime()
{
return targetTime;
}
/// <summary>
/// Gets the currently assigned target velocity.
/// </summary>
/// <returns></returns>
public Vector3 GetTargetVelocity()
{
return targetVelocity;
}
/// <summary>
/// Gets the current index of the location of the target path the AI ship will head towards.
/// </summary>
/// <returns></returns>
public int GetCurrentTargetPathLocationIndex()
{
return currentTargetPathLocationIndex;
}
/// <summary>
/// Gets the previous index of the location of the target path the AI ship is heading away from.
/// </summary>
/// <returns></returns>
public int GetPreviousTargetPathLocationIndex()
{
return prevTargetPathLocationIndex;
}
/// <summary>
/// Get the time value between the previous Target Path Location
/// and the current (next) Location along the Path. The TValue
/// should be between 0.0 and 1.0.
/// </summary>
/// <returns></returns>
public float GetCurrentTargetPathTValue()
{
return currentTargetPathTValue;
}
/// <summary>
/// Gets the current stage index for the current state. This (zero-based) index is used to keep track of what stage
/// the AI ship has reached in the current state.
/// </summary>
/// <returns></returns>
public int GetCurrentStateStageIndex()
{
return currentStateStageIndex;
}
/// <summary>
/// Returns an enumeration indicating what the current state action for this AI ship is.
/// </summary>
/// <returns></returns>
public AIStateActionInfo GetCurrentStateAction ()
{
// Get the current state ID
int currentStateId = currentState.id;
// Set the AI state action info accordingly
AIStateActionInfo aiStateActionInfo = AIStateActionInfo.Custom;
if (currentStateId == AIState.idleStateID)
{
aiStateActionInfo = AIStateActionInfo.Idle;
}
else if (currentStateId == AIState.moveToStateID)
{
if (targetPath != null) { aiStateActionInfo = AIStateActionInfo.MoveToFollowPath; }
else if (targetLocation != null) { aiStateActionInfo = AIStateActionInfo.MoveToSeekLocation; }
else { aiStateActionInfo = AIStateActionInfo.MoveToSeekPosition; }
}
else if (currentStateId == AIState.dogfightStateID)
{
aiStateActionInfo = AIStateActionInfo.DogfightAttackShip;
}
else if (currentStateId == AIState.dockingStateID)
{
aiStateActionInfo = AIStateActionInfo.Docking;
}
else if (currentStateId == AIState.strafingRunStateID)
{
aiStateActionInfo = AIStateActionInfo.StrafingRun;
}
else
{
aiStateActionInfo = AIStateActionInfo.Custom;
}
return aiStateActionInfo;
}
#endregion
#region Input API Methods
/// <summary>
/// Re-initialise (set) the shipInput based on the is[axis/button]DataDiscard field settings.
/// Must be called after each change to any of those fields/variables.
/// </summary>
public void ReinitialiseDiscardData()
{
shipInput.isHorizontalDataEnabled = !isHorizontalDataDiscarded;
shipInput.isVerticalDataEnabled = !isVerticalDataDiscarded;
shipInput.isLongitudinalDataEnabled = !isLongitudinalDataDiscarded;
shipInput.isPitchDataEnabled = !isPitchDataDiscarded;
shipInput.isYawDataEnabled = !isYawDataDiscarded;
shipInput.isRollDataEnabled = !isRollDataDiscarded;
shipInput.isPrimaryFireDataEnabled = !isPrimaryFireDataDiscarded;
shipInput.isSecondaryFireDataEnabled = !isSecondaryFireDataDiscarded;
shipInput.isDockDataEnabled = !isDockDataDiscarded;
}
#endregion
#region State API Methods
/// <summary>
/// Sets the current state for this AI ship using the given state ID.
/// </summary>
/// <param name="stateID"></param>
public void SetState (int newStateID)
{
int prevStateId = GetState();
// Get state with the corresponding state ID and set it to the current state object
currentState = AIState.GetState(newStateID);
// State action starts as uncompleted
hasCompletedStateAction = false;
// Current state stage index starts as zero
currentStateStageIndex = 0;
#if UNITY_EDITOR
// Raise a warning if the state retrieved is null
if (currentState == null)
{
Debug.LogWarning("ERROR: ShipAIInputModule.SetState: " + newStateID + " is not a valid state ID.");
}
#endif
// If required, send a notification of the state change to the developer-supplied custom method
if (callbackOnStateChange != null) { callbackOnStateChange.Invoke(this, GetState(), prevStateId); }
}
/// <summary>
/// Returns the state ID of the current state for this AI ship.
/// Returns -1 if the currentState is not set.
/// To get the instance of the state call
/// AIState.GetState(shipAIInputMdoule.GetState())
/// </summary>
/// <param name="stateID"></param>
public int GetState ()
{
// Return the current state object's state ID
return currentState != null ? currentState.id : -1;
}
/// <summary>
/// Returns whether the state action has been completed yet.
/// </summary>
/// <returns></returns>
public bool HasCompletedStateAction () { return hasCompletedStateAction; }
/// <summary>
/// Set whether the state action has been completed yet. Typically this should only be called from within a state method.
/// </summary>
/// <param name="isCompleted"></param>
public void SetHasCompletedStateAction (bool isCompleted = true) { hasCompletedStateAction = isCompleted; }
#endregion
#region Movement API Methods
// IMPORTANT: If you're looking to fly an AI ship to somewhere look at the
// SetState(..) and AssignTarget[Path | Location | Position | Ship] API methods
// Also read the chapter on Ship AI System in the manual.
/// <summary>
/// Teleport the (AI) ship to a new location by moving by an amount
/// in the x, y and z directions. This could be useful if changing
/// the origin or centre of your world to compensate for float-point
/// error.
/// NOTE: This does not alter the current Respawn position.
/// </summary>
/// <param name="delta"></param>
/// <param name="resetVelocity"></param>
public void TelePort(Vector3 delta, bool resetVelocity)
{
// Remeber current situation of the ship
bool isMovementEnabled = false;
if (isInitialised) { shipControlModule.DisableShipMovement(); isMovementEnabled = true; }
// if the TargetPosition is set, update it
if (targetPosition.x != 0f || targetPosition.y != 0f || targetPosition.z != 0f)
{
targetPosition += delta;
}
transform.position += delta;
//shipControlModule.ShipRigidbody.MovePosition(transform.position);
// If movement was enabled, re-enable it
if (isMovementEnabled)
{
shipControlModule.EnableShipMovement(resetVelocity);
shipControlModule.shipInstance.UpdatePositionAndMovementData(transform, shipControlModule.ShipRigidbody);
}
}
#endregion
#endregion
}
}
Reference in New Issue View Git Blame Copy Permalink