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

5522 lines
283 KiB
C#
Raw Normal View History

InitCommit
2023-07-24 16:38:13 +03:00
#define _SSC_SHIP_DEBUG
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
// For Math functions instead of Mathf
using System;
// Sci-Fi Ship Controller. Copyright (c) 2018-2023 SCSM Pty Ltd. All rights reserved.
namespace SciFiShipController
{
/// <summary>
/// Class containing data for a ship.
/// </summary>
[System.Serializable]
public class Ship
{
#region Enumerations
public enum ShipPhysicsModel
{
PhysicsBased = 10,
Arcade = 20
}
public enum GroundNormalCalculationMode
{
SingleNormal = 10,
SmoothedNormal = 20
//AverageHeight = 30
}
public enum RollControlMode
{
YawInput = 10,
StrafeInput = 20
}
public enum ShipDamageModel
{
Simple = 10,
Progressive = 20,
Localised = 30
}
public enum RespawningMode
{
DontRespawn = 10,
RespawnAtOriginalPosition = 20,
RespawnAtLastPosition = 30,
RespawnAtSpecifiedPosition = 40,
RespawnOnPath = 50
}
public enum StuckAction
{
DoNothing = 10,
InvokeCallback = 20,
RespawnOnPath = 30,
SameAsRespawningMode = 50
}
public enum InputControlAxis
{
None = 0,
X = 1,
Y = 2
}
#endregion
#region Public Variables and Properties
// IMPORTANT - when changing this section also update SetClassDefault()
// Also update ClassName(ClassName className) Clone Constructor (if there is one)
/// <summary>
/// If enabled, the InitialiseShip() will be called as soon as Awake() runs for the ship. This should be disabled if you are
/// instantiating the ship through code.
/// </summary>
public bool initialiseOnAwake;
/// <summary>
/// What physics model the ship uses. If you modify this, call ReinitialiseShipPhysicsModel().
/// Physics Based: Physics-based model. Physically realistic thrusters and aerodynamic devices are used to control the ship's motion.
/// Arcade: Simplified physics model. Some physical effects are simplified and unrealistic effects can be used to enhance gameplay.
/// </summary>
public ShipPhysicsModel shipPhysicsModel;
// Physical characteristics
/// <summary>
/// Mass of the ship in kilograms. If you modify this, call ReinitialiseMass() on the ShipControlModule.
/// </summary>
public float mass;
/// <summary>
/// Centre of mass of the ship in local space. If you modify this, call ReinitialiseMass() on the ShipControlModule.
/// </summary>
public Vector3 centreOfMass;
/// <summary>
/// If set to true, the centre of mass will be set to the value of centreOfMass.
/// Otherwise the centre of mass will be set to the unity default specified by the rigdbody.
/// NOTE: This value will not affect anything if changed at runtime.
/// </summary>
public bool setCentreOfMassManually;
/// <summary>
/// Show the centre of mass gizmos in the scene view.
/// </summary>
public bool showCOMGizmosInSceneView;
/// <summary>
/// Show the centre of lift and lift direction gizmos in the scene view.
/// </summary>
public bool showCOLGizmosInSceneView;
/// <summary>
/// Show the centre of forwards thrust gizmos in the scene view.
/// </summary>
public bool showCOTGizmosInSceneView;
/// <summary>
/// List of all thruster components for this ship. If you modify this, call ReinitialiseThrusterVariables() and ReinitialiseInputVariables().
/// </summary>
public List<Thruster> thrusterList;
/// <summary>
/// When the ship is enabled, but ship movement is disabled, should thrusters fire
/// if they have isMinEffectsAlwaysOn enabled?
/// </summary>
public bool isThrusterFXStationary;
/// <summary>
/// Are the thruster systems online or in the process of coming online?
/// At runtime call shipInstance.StartupThrusterSystems() or ShutdownThrusterSystems()
/// </summary>
public bool isThrusterSystemsStarted;
/// <summary>
/// The time, in seconds, it takes for the thrusters to fully come online
/// </summary>
[Range(0f, 60f)] public float thrusterSystemStartupDuration;
/// <summary>
/// The time, in seconds, it takes for the thrusters to fully shutdown
/// </summary>
[Range(0f, 60f)] public float thrusterSystemShutdownDuration;
/// <summary>
/// For thrusters, use a central fuel level, rather than fuel level per thruster.
/// </summary>
public bool useCentralFuel;
/// <summary>
/// The amount of fuel available when useCentralFuel is true - range 0.0 (empty) to 100.0 (full).
/// At runtime call shipInstance.SetFuelLevel(..)
/// </summary>
[Range(0f, 100f)] public float centralFuelLevel;
/// <summary>
/// List of all wing components for this ship. If you modify this, call ReinitialiseWingVariables().
/// </summary>
public List<Wing> wingList;
/// <summary>
/// List of all control surface components for this ship. If you modify this, call ReinitialiseInputVariables().
/// </summary>
public List<ControlSurface> controlSurfaceList;
/// <summary>
/// List of all weapon components for this ship. If you modify this, call ReinitialiseWeaponVariables().
/// </summary>
public List<Weapon> weaponList;
/// <summary>
/// When the ship is enabled, but movement is disabled, weapons and damage are updated
/// </summary>
public bool useWeaponsWhenMovementDisabled = false;
/// <summary>
/// [READ ONLY] The number of weapons on this ship
/// </summary>
public int NumberOfWeapons { get { return weaponList == null ? 0 : weaponList.Count; } }
/// <summary>
/// [Internal Use] Is the thruster systems section expanded in the SCM Editor?
/// </summary>
public bool isThrusterSystemsExpanded;
/// <summary>
/// [Internal Use] Is the thruster list expanded in the SCM Editor?
/// </summary>
public bool isThrusterListExpanded;
/// <summary>
/// [Internal Use] Is the wing list expanded in the SCM Editor?
/// </summary>
public bool isWingListExpanded;
/// <summary>
/// [Internal Use] Is the control surface list expanded in the SCM Editor?
/// </summary>
public bool isControlSurfaceListExpanded;
/// <summary>
/// [Internal Use] Is the weapon list expanded in the SCM Editor?
/// </summary>
public bool isWeaponListExpanded;
/// <summary>
/// [Internal Use] Is the main damage expanded in the SCM Editor?
/// </summary>
public bool isMainDamageExpanded;
/// <summary>
/// [Internal Use] Is the local damage list expanded in the SCM Editor?
/// </summary>
public bool isDamageListExpanded;
/// <summary>
/// Whether the Damge is shown as expanded in the inspector window of the editor.
/// </summary>
public bool showDamageInEditor;
// Aerodynamic properties
/// <summary>
/// The drag coefficients in the local x, y and z directions. Increasing the drag coefficients will increase drag.
/// </summary>
public Vector3 dragCoefficients;
/// <summary>
/// The projected areas (in square metres) of the ship in the local x, y and z planes.
/// </summary>
public Vector3 dragReferenceAreas;
/// <summary>
/// The centre of drag for moments causing rotation along the local x-axis.
/// </summary>
public Vector3 centreOfDragXMoment;
/// <summary>
/// The centre of drag for moments causing rotation along the local y-axis.
/// </summary>
public Vector3 centreOfDragYMoment;
/// <summary>
/// The centre of drag for moments causing rotation along the local z-axis.
/// </summary>
public Vector3 centreOfDragZMoment;
/// <summary>
/// Multiplier of the effect of angular drag. Only relevant when not in physics-based mode (when in this mode it is set to the physically realistic value of 1).
/// </summary>
[Range(0f, 4f)] public float angularDragFactor;
/// <summary>
/// When this is enabled, drag moments have no effect (i.e. drag cannot cause the ship to rotate). Only relevant when not in physics-based mode (when in this mode drag moments are always enabled).
/// </summary>
public bool disableDragMoments;
/// <summary>
/// A multiplier for drag moments causing rotation along the local (pitch) x-axis. Decreasing this will make these moments weaker.
/// </summary>
[Range(0f, 1f)] public float dragXMomentMultiplier;
/// <summary>
/// A multiplier for drag moments causing rotation along the local (yaw) y-axis. Decreasing this will make these moments weaker.
/// </summary>
[Range(0f, 1f)] public float dragYMomentMultiplier;
/// <summary>
/// A multiplier for drag moments causing rotation along the local (roll) z-axis. Decreasing this will make these moments weaker.
/// </summary>
[Range(0f, 1f)] public float dragZMomentMultiplier;
/// <summary>
/// How strong the effect of stalling is on wings (between 0 and 1). Higher values make the effect of stalling more prominent.
/// </summary>
[Range(0f, 1f)] public float wingStallEffect;
/// <summary>
/// Whether a braking component is enabled in arcade mode.
/// </summary>
public bool arcadeUseBrakeComponent;
/// <summary>
/// The strength of the brake force in arcade mode. Only relevant when not in physics-based mode and when
/// arcadeUseBrakeComponent is enabled.
/// </summary>
public float arcadeBrakeStrength;
/// <summary>
/// Whether the strength of the brake force ignores the density of the medium the ship is in (assuming it to be a constant
/// value of one kilogram per cubic metre). Only relevant when not in physics-based mode and when arcadeUseBrakeComponent
/// is enabled.
/// </summary>
public bool arcadeBrakeIgnoreMediumDensity;
/// <summary>
/// The minimum braking acceleration (in metres per second) caused by the brake when the brake is fully engaged. Increase this
/// value to make the ship come to a stop more quickly at low speeds. Only relevant when not in physics-based mode and when
/// arcadeUseBrakeComponent is enabled.
/// </summary>
public float arcadeBrakeMinAcceleration;
// Input modulation
/// <summary>
/// Strength of the rotational flight assist. Set to zero to disable.
/// </summary>
[Range(0f, 10f)] public float rotationalFlightAssistStrength;
/// <summary>
/// Strength of the translational flight assist. Set to zero to disable.
/// </summary>
[Range(0f, 10f)] public float translationalFlightAssistStrength;
/// <summary>
/// Strength of the stability flight assist. Set to zero to disable.
/// </summary>
[Range(0f, 10f)] public float stabilityFlightAssistStrength;
/// <summary>
/// Strength of the brake flight assist. Set to zero to disable [Default = 0]
/// Operates on Forward and Backward movements when there is no ship input.
/// Is overridden in forwards direction when AutoCruise is enabled on PlayerInputModule.
/// </summary>
[Range(0f, 10f)] public float brakeFlightAssistStrength;
/// <summary>
/// The effective minimum speed in m/s that the brake flight assist will operate
/// </summary>
[Range(-1000f, 1000f)] public float brakeFlightAssistMinSpeed;
/// <summary>
/// The effective maximum speed in m/s that the brake flight assist will operate
/// </summary>
[Range(-1000f, 1000f)] public float brakeFlightAssistMaxSpeed;
/// <summary>
/// How much power of the ship's roll thrusters is used to execute roll maneuvers.
/// Increasing this value will increase the roll speed and responsiveness of the ship.
/// </summary>
[Range(0f, 1f)] public float rollPower;
/// <summary>
/// How much power of the ship's roll thrusters is used to execute pitching maneuvers.
/// Increasing this value will increase the pitch speed and responsiveness of the ship.
/// </summary>
[Range(0f, 1f)] public float pitchPower;
/// <summary>
/// How much power of the ship's roll thrusters is used to execute yaw maneuvers.
/// Increasing this value will increase the yaw speed and responsiveness of the ship.
/// </summary>
[Range(0f, 1f)] public float yawPower;
/// <summary>
/// How much steering inputs are prioritised over lateral inputs for thrusters.
/// A value of 0 means no prioritisation takes place, while a value of 1 will almost completely deactivate relevant lateral
/// thrusters whenever any opposing steering input at all is applied.
/// </summary>
[Range(0f, 1f)] public float steeringThrusterPriorityLevel;
/// <summary>
/// Whether pitch and roll is limited within a certain range.
/// </summary>
public bool limitPitchAndRoll;
/// <summary>
/// The maximum allowed pitch (in degrees). Only relevant when limitPitchAndRoll is set to true.
/// </summary>
[Range(0f, 75f)] public float maxPitch;
/// <summary>
/// The maximum allowed roll (in degrees) when turning. Only relevant when limitPitchAndRoll is set to true.
/// </summary>
[Range(0f, 75f)] public float maxTurnRoll;
/// <summary>
/// How quickly the ship pitches (in degrees per second) when pitch and roll is limited to a certain range. Only relevant when limitPitchAndRoll is set to true.
/// </summary>
[Range(10f, 90f)] public float pitchSpeed;
/// <summary>
/// How quickly the ship rolls (in degrees per second) when pitch and roll is limited to a certain range. Only relevant when limitPitchAndRoll is set to true.
/// </summary>
[Range(10f, 90f)] public float turnRollSpeed;
/// <summary>
/// The mode currently being used for controlling roll. Only relevant when limitPitchAndRoll is set to true.
/// Yaw Input: The ship's roll is dependent on the yaw input.
/// Strafe Input: The ship's roll is dependent on the left-right strafe input.
/// </summary>
public RollControlMode rollControlMode;
/// <summary>
/// How quickly the ship pitches and rolls to match the target pitch and roll. Only relevant when limitPitchAndRoll is set to true.
/// </summary>
[Range(1f, 10f)] public float pitchRollMatchResponsiveness;
/// <summary>
/// Whether the ship will attempt to maintain a constant distance from the detectable ground surface.
/// </summary>
public bool stickToGroundSurface;
/// <summary>
/// Helps the ship to avoid crashing into the ground below it
/// </summary>
public bool avoidGroundSurface;
/// <summary>
/// Whether the ship will orient itself upwards when a ground surface is not detectable.
/// </summary>
public bool orientUpInAir;
/// <summary>
/// The distance from the ground the ship will attempt to maintain. Only relevant when stickToGroundSurface is set to true.
/// </summary>
public float targetGroundDistance;
/// <summary>
/// Whether the movement used for matching the Target Distance from the ground is smoothed. Enable this to prevent the ship
/// from accelerating too quickly when near the Target Distance. Only relevant when stickToGroundSurface is set to true.
/// If you modify this, call ReinitialiseGroundMatchVariables().
/// </summary>
public bool useGroundMatchSmoothing;
/// <summary>
/// Whether the ground match algorithm "looks ahead" to detect obstacles ahead of the ship.
/// Only relevant when stickToGroundSurface is set to true.
/// </summary>
public bool useGroundMatchLookAhead;
/// <summary>
/// The minimum distance from the ground the ship will attempt to maintain. Only relevant when stickToGroundSurface and
/// useGroundMatchSmoothing is set to true.
/// </summary>
public float minGroundDistance;
/// <summary>
/// The minimum distance from the ground the ship will attempt to maintain. Only relevant when stickToGroundSurface and
/// useGroundMatchSmoothing is set to true.
/// </summary>
public float maxGroundDistance;
/// <summary>
/// The maximum distance to check for the ground from the bottom of the ship via raycast.
/// Only relevant when stickToGroundSurface is set to true.
/// </summary>
[Range(0f, 100f)] public float maxGroundCheckDistance;
/// <summary>
/// How responsive the ship is to sudden changes in the distance to the ground.
/// Increasing this value will allow the ship to match the Target Distance more closely but may lead to a juddering effect
/// if increased too much. Only relevant when stickToGroundSurface is set to true.
/// If you modify this, call ReinitialiseGroundMatchVariables().
/// </summary>
[Range(1f, 100f)] public float groundMatchResponsiveness;
/// <summary>
/// How much the up/down motion of the ship is damped when attempting to match the Target Distance.
/// Increasing this value will reduce overshoot but may make the movement too rigid if increased too much.
/// Only relevant when stickToGroundSurface is set to true.
/// If you modify this, call ReinitialiseGroundMatchVariables().
/// </summary>
[Range(1f, 100f)] public float groundMatchDamping;
/// <summary>
/// The limit to how quickly the ship can accelerate to maintain the Target Distance to the ground.
/// Increasing this value will allow the ship to match the Target Distance more closely but may look less natural.
/// If you modify this, call ReinitialiseGroundMatchVariables().
/// </summary>
[Range(1f, 4f)] public float maxGroundMatchAccelerationFactor;
/// <summary>
/// The limit (when at the Target Distance from the ground) to how quickly the ship can accelerate to maintain the Target
/// Distance to the ground. Increasing this value will allow the ship to match the Target Distance more closely but may
/// look less natural. Only relevant when stickToGroundSurface and useGroundMatchSmoothing is set to true.
/// If you modify this, call ReinitialiseGroundMatchVariables().
/// </summary>
public float centralMaxGroundMatchAccelerationFactor;
/// <summary>
/// How the normal direction (orientation) is determined.
/// When Single Normal is selected, the single normal of each face of the ground geometry is used.
/// When Smoothed Normal is selected, the normals on each vertex of the face of the ground geometry are blended together to give a smoothed normal, which is used instead.
/// Smoothed Normal is more computationally expensive.
/// </summary>
public GroundNormalCalculationMode groundNormalCalculationMode;
/// <summary>
/// The number of past frames (including this frame) used to average ground normals over. Increase this value to make pitch and roll
/// movement smoother. Decrease this value to make pitch and roll movement more responsive to changes in the ground
/// surface. Only relevant when stickToGroundSurface is set to true.
/// If you modify this, call ReinitialiseGroundMatchVariables().
/// </summary>
[Range(1, 50)] public int groundNormalHistoryLength;
/// <summary>
/// Layermask determining which layers will be detected as part of the ground surface when raycasted against.
/// </summary>
public LayerMask groundLayerMask;
/// <summary>
/// The input axis to be controlled or limited. This is used to simulate 2.5D flight.
/// </summary>
public InputControlAxis inputControlAxis;
/// <summary>
/// The target value of the inputControlAxis.
/// </summary>
public float inputControlLimit;
/// <summary>
/// The rate at which force is applied to limit control
/// </summary>
[Range(0.1f, 100f)] public float inputControlMovingRigidness;
/// <summary>
/// The rate at which the ship turns to limit or correct the rotation
/// </summary>
[Range(0.1f, 100f)] public float inputControlTurningRigidness;
/// <summary>
/// Forward X angle for the plane the ship will fly in
/// </summary>
[Range(0f, 180f)] public float inputControlForwardAngle;
// Arcade physics properties
/// <summary>
/// How fast the ship accelerates when pitching up and down in degrees per second squared.
/// Increasing this value will increase how fast the ship can be pitched up and down by pilot and rotational flight assist inputs.
/// </summary>
[Range(0f, 500f)] public float arcadePitchAcceleration;
/// <summary>
/// How fast the ship accelerates when turning left and right in degrees per second squared.
/// Increasing this value will increase how fast the ship can be turned left and right by pilot and rotational flight assist inputs.
/// </summary>
[Range(0f, 500f)] public float arcadeYawAcceleration;
/// <summary>
/// How fast the ship accelerates when rolling left and right in degrees per second squared.
/// Increasing this value will increase how fast the ship can be rolled left and right by pilot and rotational flight assist inputs.
/// </summary>
[Range(0f, 500f)] public float arcadeRollAcceleration;
/// <summary>
/// How quickly the ship accelerates in metres per second squared while in the air to move in the direction the ship is facing.
/// </summary>
[Range(0f, 1000f)] public float arcadeMaxFlightTurningAcceleration;
/// <summary>
/// How quickly the ship accelerates in metres per second squared while near the ground to move in the direction the ship is facing.
/// </summary>
[Range(0f, 1000f)] public float arcadeMaxGroundTurningAcceleration;
/// <summary>
/// [INTERNAL USE ONLY] shouldn't be called directly, call SendInput in the ship control module instead
/// </summary>
public Vector3 pilotForceInput { private get; set; }
/// <summary>
/// [INTERNAL USE ONLY] shouldn't be called directly, call SendInput in the ship control module instead
/// </summary>
public Vector3 pilotMomentInput { private get; set; }
/// <summary>
/// [INTERNAL USE ONLY] shouldn't be called directly, call SendInput in the ship control module instead
/// </summary>
public bool pilotPrimaryFireInput { private get; set; }
/// <summary>
/// [INTERNAL USE ONLY] shouldn't be called directly, call SendInput in the ship control module instead
/// </summary>
public bool pilotSecondaryFireInput { private get; set; }
/// <summary>
/// The density (in kilograms per cubic metre) of the fluid the ship is travelling through (usually air).
/// </summary>
public float mediumDensity;
/// <summary>
/// The magnitude of the acceleration (in metres per second squared) due to gravity.
/// </summary>
public float gravitationalAcceleration;
/// <summary>
/// The direction in world space in which gravity acts upon the ship.
/// </summary>
public Vector3 gravityDirection;
// TODO: Update comment when adding more damage models
/// <summary>
/// What damage model the ship uses.
/// Simple: Simplistic damage model with a single health value. Effects of damage are only visual until the ship is destroyed.
/// Progressive: More complex damage model. As the ship takes damage the performance of parts is affected.
/// Localised: More complex damage model. Similar to progressive, but different parts can be damaged independently of each other.
/// If you modify this, call ReinitialiseDamageRegionVariables().
/// </summary>
public ShipDamageModel shipDamageModel;
/// <summary>
/// Damage Region used in the simple and progressive damage models.
/// If you modify this, call ReinitialiseDamageRegionVariables().
/// NOTE: Not required if just changing the Health or ShieldHealth
/// </summary>
public DamageRegion mainDamageRegion;
/// <summary>
/// List of Damage Regions used in the localised damage model.
/// If you modify this, call ReinitialiseDamageRegionVariables().
/// NOTE: Not required if just changing the Health or ShieldHealth
/// </summary>
public List<DamageRegion> localisedDamageRegionList;
/// <summary>
/// Whether damage multipliers are used when calculating damage from projectiles.
/// </summary>
public bool useDamageMultipliers;
/// <summary>
/// Whether damage multipliers are localised (i.e. there are different sets of damage multipliers for each damage region
/// of the ship). Only relevant when useDamageMultipliers is set to true and shipDamageModel is set to Localised.
/// </summary>
public bool useLocalisedDamageMultipliers;
/// <summary>
/// [READONLY]
/// Normalised (0.0 – 1.0) value of the overall health of the ship. To get the actual health values, see the damageRegions of the ship.
/// </summary>
public float HealthNormalised
{
get
{
float _healthN = mainDamageRegion.startingHealth == 0f ? 0f : mainDamageRegion.Health / mainDamageRegion.startingHealth;
if (_healthN > 1f) { return 1f; }
else if (_healthN < 0f) { return 0f; }
else { return _healthN; }
}
}
/// <summary>
/// How respawning happens. If you change this to RespawningMode.RespawnAtLastPosition, call ReinitialiseRespawnVariables().
/// </summary>
public RespawningMode respawningMode;
/// <summary>
/// How long the respawning process takes (in seconds). Only relevant when respawningMode is not set to DontRespawn.
/// </summary>
public float respawnTime;
/// <summary>
/// The time (in seconds) between updates of the collision respawn position. Hence when the ship is destroyed by colliding with
/// something, the ship respawn position will be where the ship was between this time ago and twice this time ago. Only
/// relevant when respawningMode is set to RespawnAtLastPosition.
/// </summary>
public float collisionRespawnPositionDelay;
/// <summary>
/// Where the ship respawns from in world space when respawningMode is set to RespawnFromSpecifiedPosition.
/// </summary>
public Vector3 customRespawnPosition;
/// <summary>
/// The rotation the ship respawns from in world space when respawningMode is set to RespawnFromSpecifiedPosition.
/// </summary>
public Vector3 customRespawnRotation;
/// <summary>
/// The velocity the ship respawns with in local space. Only relevant when respawningMode is not set to DontRespawn.
/// </summary>
public Vector3 respawnVelocity;
/// <summary>
/// guidHash code of the Path which the ship will be respawned on when respawningMode is RespawnOnPath.
/// </summary>
public int respawningPathGUIDHash;
/// <summary>
/// [READONLY] The current respawn position
/// </summary>
public Vector3 RespawnPosition { get { return currentRespawnPosition; } }
/// <summary>
/// Whether controller rumble is applied to the ship by the ship control module.
/// </summary>
public bool applyControllerRumble = false;
/// <summary>
/// The minimum amount of damage that will cause controller rumble.
/// </summary>
public float minRumbleDamage = 0f;
/// <summary>
/// The amount of damage corresponding to maximum controller rumble.
/// </summary>
public float maxRumbleDamage = 10f;
/// <summary>
/// The time (in seconds) that a controller rumble event lasts for.
/// </summary>
[Range(0.1f, 5f)] public float damageRumbleTime = 0.5f;
/// <summary>
/// The amount of time that needs to elapse before a stationary ship is considered stuck.
/// When the value is 0, a stationary ship is never considered stuck.
/// </summary>
[Range(0f, 300)] public float stuckTime;
/// <summary>
/// The maximum speed in m/sec the ship can be moving before it can be considered stuck
/// </summary>
[Range(0f, 1f)] public float stuckSpeedThreshold;
/// <summary>
/// The action to take when the ship is deemed stationary or stuck.
/// </summary>
public StuckAction stuckAction;
/// <summary>
/// guidHash code of the Path which the ship will be respawned on when it is stuck
/// and the StuckAction is RespawnOnPath.
/// </summary>
public int stuckActionPathGUIDHash;
/// <summary>
/// [READONLY] The world velocity of the ship as a vector. Derived from the velocity of the rigidbody.
/// </summary>
public Vector3 WorldVelocity { get { return worldVelocity; } }
/// <summary>
/// [READONLY] The local velocity of the ship as a vector. Derived from the velocity of the rigidbody.
/// </summary>
public Vector3 LocalVelocity { get { return localVelocity; } }
/// <summary>
/// [READONLY] The world angular velocity of the ship as a vector. Derived from the angular velocity of the rigidbody.
/// </summary>
public Vector3 WorldAngularVelocity { get { return worldAngularVelocity; } }
/// <summary>
/// [READONLY] The local angular velocity of the ship as a vector. Derived from the angular velocity of the rigidbody.
/// </summary>
public Vector3 LocalAngularVelocity { get { return localAngularVelocity; } }
/// <summary>
/// [READONLY] The pitch angle, in degrees, above or below the artificial horizon
/// </summary>
public float PitchAngle { get { return Vector3.SignedAngle(new Vector3(trfmFwd.x, 0f, trfmFwd.z), trfmFwd, Vector3.right) * Mathf.Sign(-Vector3.Dot(Vector3.forward, trfmFwd)); } }
/// <summary>
/// [READONLY] The roll angle, in degrees, left (-ve) or right (+ve)
/// </summary>
public float RollAngle { get { Vector3 _localUpNormal = trfmInvRot * Vector3.up; return -Mathf.Atan2(_localUpNormal.x, _localUpNormal.y) * Mathf.Rad2Deg; } }
/// <summary>
/// [READONLY] The rigidbody position of the ship as a vector. Derived from the position of the rigidbody. This is
/// where the physics engine says the ship is.
/// </summary>
public Vector3 RigidbodyPosition { get { return rbodyPos; } }
/// <summary>
/// [READONLY] The rigidbody rotation of the ship as a vector. Derived from the rotation of the rigidbody. This is
/// where the physics engine says the ship is rotated.
/// </summary>
public Quaternion RigidbodyRotation { get { return rbodyRot; } }
/// <summary>
/// [READONLY] The rigidbody inverse rotation of the ship as a vector. Derived from the rotation of the rigidbody. This is
/// the inverse of where the physics engine says the ship is rotated.
/// </summary>
public Quaternion RigidbodyInverseRotation { get { return rbodyInvRot; } }
/// <summary>
/// [READONLY] The rigidbody forward direction of the ship as a vector. Derived from the rotation of the rigidbody. This is
/// the direction the physics engine says the ship is facing.
/// </summary>
public Vector3 RigidbodyForward { get { return rbodyFwd; } }
/// <summary>
/// [READONLY] The rigidbody right direction of the ship as a vector. Derived from the rotation of the rigidbody. This is
/// the direction the physics engine says the ship's right direction is facing.
/// </summary>
public Vector3 RigidbodyRight { get { return rbodyRight; } }
/// <summary>
/// [READONLY] The rigidbody up direction of the ship as a vector. Derived from the rotation of the rigidbody. This is
/// the direction the physics engine says the ship's up direction is facing.
/// </summary>
public Vector3 RigidbodyUp { get { return rbodyUp; } }
/// <summary>
/// [READONLY] The position of the ship as a vector. Derived from the position of the transform. You should use
/// RigidbodyPosition instead if you are using the data for physics calculations.
/// </summary>
public Vector3 TransformPosition { get { return trfmPos; } }
/// <summary>
/// [READONLY] The forward direction of the ship in world space as a vector. Derived from the forward direction of the transform.
/// You should use RigidbodyForward instead if you are using the data for physics calculations.
/// </summary>
public Vector3 TransformForward { get { return trfmFwd; } }
/// <summary>
/// [READONLY] The right direction of the ship in world space as a vector. Derived from the right direction of the transform.
/// You should use RigidbodyRight instead if you are using the data for physics calculations.
/// </summary>
public Vector3 TransformRight { get { return trfmRight; } }
/// <summary>
/// [READONLY] The up direction of the ship in world space as a vector. Derived from the up direction of the transform.
/// You should use RigidbodyUp instead if you are using the data for physics calculations.
/// </summary>
public Vector3 TransformUp { get { return trfmUp; } }
/// <summary>
/// [READONLY] The rotation of the ship in world space as a quaternion. Derived from the rotation of the transform.
/// You should use RigidbodyRotation instead if you are using the data for physics calculations.
/// </summary>
public Quaternion TransformRotation { get { return trfmRot; } }
/// <summary>
/// [READONLY] The inverse rotation of the ship in world space as a quaternion. Derived from the rotation of the transform.
/// You should use RigidbodyInverseRotation instead if you are using the data for physics calculations.
/// </summary>
public Quaternion TransformInverseRotation { get { return trfmInvRot; } }
/// <summary>
/// [READONLY] Whether the ship is currently sticking to a ground surface.
/// </summary>
public bool IsGrounded { get { return stickToGroundSurfaceEnabled; } }
/// <summary>
/// [READONLY] The current normal of the target plane in world space. This is the upwards direction the ship will attempt to
/// orient itself to if limit pitch and roll is enabled.
/// </summary>
public Vector3 WorldTargetPlaneNormal { get { return worldTargetPlaneNormal; } }
/// <summary>
/// The faction or alliance the ship belongs to. This can be used to identify if a ship is friend or foe.
/// Default (neutral) is 0.
/// </summary>
public int factionId;
/// <summary>
/// The squadron this ship is a member of.
/// </summary>
public int squadronId;
/// <summary>
/// The relative size of the blip on the radar mini-map
/// </summary>
[Range(1, 5)] public byte radarBlipSize;
/// <summary>
/// [INTERNAL USE ONLY] Instead, call shipControlModule.EnableRadar() or DisableRadar().
/// </summary>
public bool isRadarEnabled;
/// <summary>
/// [READONLY] The number used by the SSCRadar system to identify this ship at a point in time.
/// This should not be stored across frames and is updated as required by the system.
/// </summary>
public int RadarId { get { return radarItemIndex; } }
/// <summary>
/// [INTERNAL USE ONLY]
/// </summary>
[System.NonSerialized] public SSCRadarPacket sscRadarPacket;
/// <summary>
/// Session-only transform InstanceID
/// </summary>
[System.NonSerialized] public int shipId;
/// <summary>
/// Session-only estimated maximum range of turret weapons
/// </summary>
[System.NonSerialized] public float estimatedMaxTurretRange;
/// <summary>
/// Session-only estimated maximum range of all weapons with isAutoTargetingEnabled = true
/// </summary>
[System.NonSerialized] public float estimatedMaxAutoTargetRange;
#endregion
#region Public Delegates
public delegate void CallbackOnDamage(float mainDamageRegionHealth);
public delegate void CallbackOnCameraShake(float shakeAmountNormalised);
public delegate void CallbackOnWeaponFired(Ship ship, Weapon weapon);
public delegate void CallbackOnWeaponNoAmmo(Ship ship, Weapon weapon);
/// <summary>
/// The name of the custom method that is called immediately
/// after damage has changed. Your method must take 1 float
/// parameter. This should be a lightweight method to avoid
/// performance issues. It could be used to update a HUD or
/// take some other action.
/// </summary>
[NonSerialized] public CallbackOnDamage callbackOnDamage = null;
/// <summary>
/// Generally reserved for internal use by ShipCameraModule. If you use your own
/// camera scripts, you can create a lightweight custom method and assign it at
/// runtime so that this is called whenever camera shake data is available.
/// </summary>
[NonSerialized] public CallbackOnCameraShake callbackOnCameraShake = null;
/// <summary>
/// The name of the custom method that is called immediately after
/// a weapon has fired.
/// This should be a lightweight method to avoid performance issues that
/// doesn't hold references the ship or weapon past the end of the current frame.
/// </summary>
[NonSerialized] public CallbackOnWeaponFired callbackOnWeaponFired = null;
/// <summary>
/// The name of the custom method that is called immediately after the weapon
/// runs out of ammunition. Your method must take a ship and weapon parameter.
/// This should be a lightweight method to avoid performance issues that
/// doesn't hold references the ship or weapon past the end of the current frame.
/// </summary>
[NonSerialized] public CallbackOnWeaponNoAmmo callbackOnWeaponNoAmmo = null;
#endregion
#region Private and Internal Variables
#region Private Variables - Cached
private Vector3 worldVelocity;
private Vector3 localVelocity;
private Vector3 absLocalVelocity;
private Vector3 worldAngularVelocity;
private Vector3 localAngularVelocity;
private Vector3 trfmUp;
private Vector3 trfmFwd;
private Vector3 trfmRight;
private Vector3 trfmPos;
private Vector3 rbodyPos;
private Vector3 rbodyUp;
private Vector3 rbodyFwd;
private Vector3 rbodyRight;
private Quaternion trfmRot;
private Quaternion trfmInvRot;
private Quaternion rbodyRot;
private Quaternion rbodyInvRot;
private Vector3 rBodyInertiaTensor;
private bool shipPhysicsModelPhysicsBased;
private bool shipDamageModelIsSimple;
#endregion
#region Private Variables - Timing related
private float lastFixedUpdateTime = 0f;
private Vector3 previousFrameWorldVelocity = Vector3.zero;
internal float thrusterSystemStartupTimer = 0f;
internal float thrusterSystemShutdownTimer = 0f;
#endregion
#region Private Variables - Cached input
// Is each input being used on the ship?
private bool longitudinalThrustInputUsed;
private bool horizontalThrustInputUsed;
private bool verticalThrustInputUsed;
private bool pitchMomentInputUsed;
private bool yawMomentInputUsed;
private bool rollMomentInputUsed;
#endregion
#region Private Variables - Input
private bool limitPitchAndRollEnabled = false;
private bool stickToGroundSurfaceEnabled = false;
private Vector3 forceInput = Vector3.zero;
private Vector3 momentInput = Vector3.zero;
private float pitchAmountInput = 0f, rollAmountInput = 0f;
private float pitchAmount = 0f, rollAmount = 0f;
private float maxFramePitchDelta, maxFrameRollDelta;
private float targetLocalPitch, targetLocalRoll;
private float yawVelocity;
private float flightAssistValue;
#endregion
#region Private Variables - Thruster
private Thruster thruster;
private Vector3 thrustForce = Vector3.zero;
#endregion
#region Private Variables - Aerodynamics
private float dragLength, dragWidth, dragHeight;
private float quarticLengthXProj, quarticLengthYProj;
private float quarticWidthYProj, quarticWidthZProj;
private float quarticHeightXProj, quarticHeightZProj;
private Vector3 localDragForce;
private Vector3 localLiftForce;
private Vector3 localInducedDragForce;
private float liftForceMagnitude;
private Wing wing;
private Vector3 wingPlaneNormal = Vector3.right;
private Vector3 localVeloInWingPlane = Vector3.zero;
private float wingAngleOfAttack = 0f;
private float angularDragMultiplier;
private ControlSurface controlSurface;
private float aerodynamicTrueAirspeed;
private float liftCoefficient = 0f, phi0, phi1, phi2, phi3;
private Vector3 controlSurfaceMovementAxis = Vector3.up;
private float controlSurfaceInput = 0f, controlSurfaceAngle;
private float controlSurfaceLiftDelta, controlSurfaceDragDelta;
private Vector3 controlSurfaceRelativePosition;
#endregion
#region Private Variables - Gravity
private Vector3 localGravityAcceleration;
#endregion
#region Private Variables - Arcade physics
/// <summary>
/// Note that this is actually an acceleration.
/// </summary>
private Vector3 arcadeMomentVector = Vector3.zero;
/// <summary>
/// Note that this is actually an acceleration.
/// </summary>
private Vector3 arcadeForceVector = Vector3.zero;
private float arcadeBrakeForceMagnitude = 0f;
private float arcadeBrakeForceMinMagnitude = 0f;
private float maxGroundMatchAcceleration = 0f;
private float centralMaxGroundMatchAcceleration = 0f;
// Temp ground distance input required
private float groundDistInput = 0f;
#endregion
#region Private Variables - Combat variables
private Weapon weapon;
private Vector3 weaponRelativeFirePosition = Vector3.zero;
private Vector3 weaponRelativeFireDirection = Vector3.zero;
private Vector3 weaponWorldBasePosition = Vector3.zero;
private Vector3 weaponWorldFirePosition = Vector3.zero;
private Vector3 weaponWorldFireDirection = Vector3.zero;
private Vector3 currentRespawnPosition = Vector3.zero;
private Quaternion currentRespawnRotation = Quaternion.identity;
private Vector3 currentCollisionRespawnPosition = Vector3.zero;
private Vector3 nextCollisionRespawnPosition = Vector3.zero;
private Quaternion currentCollisionRespawnRotation = Quaternion.identity;
private Quaternion nextCollisionRespawnRotation = Quaternion.identity;
private float collisionRespawnPositionTimer = 0f;
private bool lastDamageWasCollisionDamage = false;
private int weaponFiringButtonInt;
private int weaponPrimaryFiringInt, weaponSecondaryFiringInt, weaponAutoFiringInt;
private int weaponTypeInt;
private int lastDamageEventIndex = -1;
private float damageRumbleAmountRequired = 0f;
private float damageCameraShakeAmountRequired = 0f;
// Damage Regions
[System.NonSerialized] internal int numLocalisedDamageRegions;
// Radar variables
[System.NonSerialized] internal int radarItemIndex = -1;
#endregion
#region Private Variables - Collision
/// <summary>
/// Unordered unique set of colliders on objects that have been attached to this ship.
/// These are ignored during collision events
/// </summary>
[NonSerialized] private HashSet<int> attachedCollisionColliders = new HashSet<int>();
#endregion
#region Private Variables - PID Controllers
private PIDController pitchPIDController;
private PIDController rollPIDController;
private PIDController groundDistPIDController;
private PIDController rFlightAssistPitchPIDController;
private PIDController rFlightAssistYawPIDController;
private PIDController rFlightAssistRollPIDController;
private PIDController inputAxisForcePIDController;
private PIDController inputAxisMomentPIDController;
private PIDController sFlightAssistPitchPIDController;
private PIDController sFlightAssistYawPIDController;
private PIDController sFlightAssistRollPIDController;
private float sFlightAssistTargetPitch = 0f;
private float sFlightAssistTargetYaw = 0f;
private float sFlightAssistTargetRoll = 0f;
private bool sFlightAssistRotatingPitch = false;
private bool sFlightAssistRotatingYaw = false;
private bool sFlightAssistRotatingRoll = false;
#endregion
#region Private Variables - Normals
private Vector3 worldTargetPlaneNormal = Vector3.up;
private Vector3 localTargetPlaneNormal = Vector3.up;
private float currentPerpendicularGroundDist = -1f;
private MeshCollider groundMeshCollider;
private MeshCollider cachedGroundMeshCollider;
private Mesh cachedGroundMesh;
private Vector3[] cachedGroundMeshNormals;
private int[] cachedGroundMeshTriangles;
private Vector3 groundNormal0;
private Vector3 groundNormal1;
private Vector3 groundNormal2;
private Vector3 barycentricCoord;
private Vector3[] groundNormalHistory;
private int groundNormalHistoryIdx = 0;
#endregion
#region Private and Internal Variables - Misc
private int componentIndex;
private int componentListSize;
private Ray raycastRay;
private RaycastHit raycastHitInfo;
/// <summary>
/// [INTERNAL ONLY]
/// Added in 1.3.3 to support muzzle FX parenting.
/// MAY NEED TO BE REMOVED IN THE FUTURE.
/// WARNING: Not fully tested with destroying ships
/// in the scene. Need to be careful it doesn't prevent
/// garabage collection of ShipControlModule.
/// Where possible - use the cached trfmXXX itema above.
/// </summary>
[System.NonSerialized] internal Transform shipTransform;
private SSCManager sscManager = null;
// Reusable lists - typically used with GetComponents or GetComponentsInChildren to avoid GC.
//private List<ShipControlModule> tempShipControlModuleList;
// Add additional force or boost
private Vector3 boostDirection;
private float boostTimer;
private float boostForce; // in newtons
#endregion
#endregion
#region Constructors
// Class constructor
public Ship()
{
SetClassDefaults();
}
// Copy constructor
public Ship (Ship ship)
{
if (ship == null) { SetClassDefaults(); }
else
{
this.initialiseOnAwake = ship.initialiseOnAwake;
this.shipPhysicsModel = ship.shipPhysicsModel;
this.mass = ship.mass;
this.centreOfMass = ship.centreOfMass;
this.setCentreOfMassManually = ship.setCentreOfMassManually;
this.showCOMGizmosInSceneView = ship.showCOMGizmosInSceneView;
this.showCOLGizmosInSceneView = ship.showCOLGizmosInSceneView;
this.showCOTGizmosInSceneView = ship.showCOTGizmosInSceneView;
if (ship.thrusterList == null)
{
this.thrusterList = new List<Thruster>(25);
// Create a default forwards-facing thruster
Thruster thruster = new Thruster();
if (thruster != null)
{
thruster.name = "Forward Thruster";
thruster.forceUse = 1;
thruster.primaryMomentUse = 0;
thruster.secondaryMomentUse = 0;
thruster.maxThrust = 100000;
thruster.thrustDirection = Vector3.forward;
thruster.relativePosition = Vector3.zero;
this.thrusterList.Add(thruster);
}
}
else { this.thrusterList = ship.thrusterList.ConvertAll(th => new Thruster(th)); }
if (ship.wingList == null) { this.wingList = new List<Wing>(5); }
else { this.wingList = ship.wingList.ConvertAll(wg => new Wing(wg)); }
if (ship.controlSurfaceList == null) { this.controlSurfaceList = new List<ControlSurface>(10); }
else { this.controlSurfaceList = ship.controlSurfaceList.ConvertAll(cs => new ControlSurface(cs)); }
if (ship.weaponList == null) { this.weaponList = new List<Weapon>(10); }
else { this.weaponList = ship.weaponList.ConvertAll(wp => new Weapon(wp)); }
this.isThrusterSystemsExpanded = ship.isThrusterSystemsExpanded;
this.isThrusterListExpanded = ship.isThrusterListExpanded;
this.isWingListExpanded = ship.isWingListExpanded;
this.isControlSurfaceListExpanded = ship.isControlSurfaceListExpanded;
this.isWeaponListExpanded = ship.isWeaponListExpanded;
this.isMainDamageExpanded = ship.isMainDamageExpanded;
this.isDamageListExpanded = ship.isDamageListExpanded;
this.showDamageInEditor = ship.showDamageInEditor;
this.isThrusterFXStationary = ship.isThrusterFXStationary;
this.isThrusterSystemsStarted = ship.isThrusterSystemsStarted;
this.thrusterSystemStartupDuration = ship.thrusterSystemStartupDuration;
this.thrusterSystemShutdownDuration = ship.thrusterSystemShutdownDuration;
this.useCentralFuel = ship.useCentralFuel;
this.centralFuelLevel = ship.centralFuelLevel;
this.dragCoefficients = ship.dragCoefficients;
this.dragReferenceAreas = ship.dragReferenceAreas;
this.centreOfDragXMoment = ship.centreOfDragXMoment;
this.centreOfDragYMoment = ship.centreOfDragYMoment;
this.centreOfDragZMoment = ship.centreOfDragZMoment;
this.angularDragFactor = ship.angularDragFactor;
this.disableDragMoments = ship.disableDragMoments;
this.dragXMomentMultiplier = ship.dragXMomentMultiplier;
this.dragYMomentMultiplier = ship.dragYMomentMultiplier;
this.dragZMomentMultiplier = ship.dragZMomentMultiplier;
this.wingStallEffect = ship.wingStallEffect;
this.arcadeUseBrakeComponent = ship.arcadeUseBrakeComponent;
this.arcadeBrakeStrength = ship.arcadeBrakeStrength;
this.arcadeBrakeIgnoreMediumDensity = ship.arcadeBrakeIgnoreMediumDensity;
this.arcadeBrakeMinAcceleration = ship.arcadeBrakeMinAcceleration;
this.rotationalFlightAssistStrength = ship.rotationalFlightAssistStrength;
this.translationalFlightAssistStrength = ship.translationalFlightAssistStrength;
this.brakeFlightAssistStrength = ship.brakeFlightAssistStrength;
this.brakeFlightAssistMaxSpeed = ship.brakeFlightAssistMinSpeed;
this.brakeFlightAssistMaxSpeed = ship.brakeFlightAssistMaxSpeed;
this.limitPitchAndRoll = ship.limitPitchAndRoll;
this.maxPitch = ship.maxPitch;
this.maxTurnRoll = ship.maxTurnRoll;
this.pitchSpeed = ship.pitchSpeed;
this.turnRollSpeed = ship.turnRollSpeed;
this.rollControlMode = ship.rollControlMode;
this.pitchRollMatchResponsiveness = ship.pitchRollMatchResponsiveness;
this.stickToGroundSurface = ship.stickToGroundSurface;
this.avoidGroundSurface = ship.avoidGroundSurface;
this.useGroundMatchSmoothing = ship.useGroundMatchSmoothing;
this.useGroundMatchLookAhead = ship.useGroundMatchLookAhead;
this.orientUpInAir = ship.orientUpInAir;
this.targetGroundDistance = ship.targetGroundDistance;
this.minGroundDistance = ship.minGroundDistance;
this.maxGroundDistance = ship.maxGroundDistance;
this.maxGroundCheckDistance = ship.maxGroundCheckDistance;
this.groundMatchResponsiveness = ship.groundMatchResponsiveness;
this.groundMatchDamping = ship.groundMatchDamping;
this.maxGroundMatchAccelerationFactor = ship.maxGroundMatchAccelerationFactor;
this.centralMaxGroundMatchAccelerationFactor = ship.centralMaxGroundMatchAccelerationFactor;
this.groundNormalCalculationMode = ship.groundNormalCalculationMode;
this.groundNormalHistoryLength = ship.groundNormalHistoryLength;
this.groundLayerMask = ship.groundLayerMask;
this.inputControlAxis = ship.inputControlAxis;
this.inputControlLimit = ship.inputControlLimit;
this.inputControlForwardAngle = ship.inputControlForwardAngle;
this.inputControlMovingRigidness = ship.inputControlMovingRigidness;
this.inputControlTurningRigidness = ship.inputControlTurningRigidness;
this.rollPower = ship.rollPower;
this.pitchPower = ship.pitchPower;
this.yawPower = ship.yawPower;
this.steeringThrusterPriorityLevel = ship.steeringThrusterPriorityLevel;
this.pilotMomentInput = ship.pilotMomentInput;
this.pilotForceInput = ship.pilotForceInput;
this.arcadePitchAcceleration = ship.arcadePitchAcceleration;
this.arcadeYawAcceleration = ship.arcadeYawAcceleration;
this.arcadeRollAcceleration = ship.arcadeRollAcceleration;
this.arcadeMaxFlightTurningAcceleration = ship.arcadeMaxFlightTurningAcceleration;
this.arcadeMaxGroundTurningAcceleration = ship.arcadeMaxGroundTurningAcceleration;
this.mediumDensity = ship.mediumDensity;
this.gravitationalAcceleration = ship.gravitationalAcceleration;
this.gravityDirection = ship.gravityDirection;
this.shipDamageModel = ship.shipDamageModel;
if (ship.mainDamageRegion == null)
{
this.mainDamageRegion = new DamageRegion();
this.mainDamageRegion.name = "Main Damage Region";
}
else { this.mainDamageRegion = new DamageRegion(ship.mainDamageRegion); }
if (ship.localisedDamageRegionList == null) { this.localisedDamageRegionList = new List<DamageRegion>(10); }
else { this.localisedDamageRegionList = ship.localisedDamageRegionList.ConvertAll(dr => new DamageRegion(dr)); }
this.useDamageMultipliers = ship.useDamageMultipliers;
this.useLocalisedDamageMultipliers = ship.useLocalisedDamageMultipliers;
this.respawnTime = ship.respawnTime;
this.collisionRespawnPositionDelay = ship.collisionRespawnPositionDelay;
this.respawningMode = ship.respawningMode;
this.customRespawnPosition = ship.customRespawnPosition;
this.customRespawnRotation = ship.customRespawnRotation;
this.respawnVelocity = ship.respawnVelocity;
this.respawningPathGUIDHash = ship.respawningPathGUIDHash;
this.minRumbleDamage = ship.minRumbleDamage;
this.maxRumbleDamage = ship.maxRumbleDamage;
this.stuckTime = ship.stuckTime;
this.stuckSpeedThreshold = ship.stuckSpeedThreshold;
this.stuckAction = ship.stuckAction;
this.stuckActionPathGUIDHash = ship.stuckActionPathGUIDHash;
this.factionId = ship.factionId;
this.squadronId = ship.squadronId;
this.isRadarEnabled = ship.isRadarEnabled;
this.radarBlipSize = ship.radarBlipSize;
}
}
#endregion
#region Private and Internal Non-Static Methods
/// <summary>
/// [INTERNAL ONLY]
/// Check if the thruster systems are starting up or shutting down.
/// If the state has changed in this frame, like has started or shutdown, the method will return true.
/// </summary>
/// <param name="deltaTime"></param>
/// <param name="hasShutdown"></param>
/// <param name="hasStarted"></param>
/// <returns></returns>
internal bool CheckThrusterSystems(float deltaTime, out bool hasStarted, out bool hasShutdown)
{
bool hasStateChanged = false;
hasShutdown = false;
hasStarted = false;
// Is the system shutting down?
if (thrusterSystemShutdownTimer > 0f)
{
thrusterSystemShutdownTimer += deltaTime;
//Debug.Log("[DEBUG] Thruster System shutting down: " + thrusterSystemShutdownTimer);
if (thrusterSystemShutdownTimer > thrusterSystemShutdownDuration)
{
ShutdownThrusterSystems(true);
hasStateChanged = true;
hasShutdown = true;
}
else
{
SetThrottleAllThrusters(1f - thrusterSystemShutdownTimer / thrusterSystemShutdownDuration);
}
}
else if (thrusterSystemStartupTimer > 0f)
{
thrusterSystemStartupTimer += deltaTime;
//Debug.Log("[DEBUG] Thruster System starting up: " + thrusterSystemStartupTimer);
if (thrusterSystemStartupTimer > thrusterSystemStartupDuration)
{
StartupThrusterSystems(true);
hasStateChanged = true;
hasStarted = true;
}
else
{
SetThrottleAllThrusters(thrusterSystemStartupTimer / thrusterSystemStartupDuration);
}
}
return hasStateChanged;
}
/// <summary>
/// Reset the thruster systems variables and thruster throttle values.
/// The systems might have been starting or shutting down when the ship
/// was destroyed.
/// Typically used when a ship is respawned.
/// </summary>
internal void ResetThrusterSystems()
{
// If the systems are starting or shutting down, reset all the
// thruster throttle values.
if (thrusterSystemStartupTimer > 0f || thrusterSystemShutdownTimer > 0f)
{
SetThrottleAllThrusters(isThrusterSystemsStarted ? 1f : 0f);
}
thrusterSystemShutdownTimer = 0f;
thrusterSystemStartupTimer = 0f;
}
/// <summary>
/// Returns the angle between two vectors projected into a specified plane, with a sign indicating the direction.
/// </summary>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="planeNormal"></param>
/// <returns></returns>
private float SignedAngleInPlane(Vector3 from, Vector3 to, Vector3 planeNormal)
{
return Vector3.SignedAngle(Vector3.ProjectOnPlane(from, planeNormal), Vector3.ProjectOnPlane(to, planeNormal), planeNormal);
}
/// <summary>
/// Returns a float number raised to an integer power.
/// </summary>
/// <param name="baseNum"></param>
/// <param name="indexNum"></param>
/// <returns></returns>
private float IntegerPower(float baseNum, int powerNum)
{
// Start power calculation at power of zero instead of power of one, so that anything to the power of zero is one
float resultNum = 1f;
// Iteratively mutiply by the base number
for (int i = 0; i < powerNum; i++) { resultNum *= baseNum; }
return resultNum;
}
/// <summary>
/// Returns the damped (averaged) normal.
/// </summary>
/// <param name="currentNormal"></param>
/// <returns></returns>
private Vector3 GetDampedGroundNormal()
{
Vector3 dampedNormal = Vector3.zero;
// Loop through ground normal
for (int hIdx = 0; hIdx < groundNormalHistoryLength; hIdx++)
{
// Optimise by setting each axis rather than creating new vectors
dampedNormal.x += groundNormalHistory[hIdx].x;
dampedNormal.y += groundNormalHistory[hIdx].y;
dampedNormal.z += groundNormalHistory[hIdx].z;
}
dampedNormal.x *= 1f / groundNormalHistoryLength;
dampedNormal.y *= 1f / groundNormalHistoryLength;
dampedNormal.z *= 1f / groundNormalHistoryLength;
return dampedNormal.normalized;
}
/// <summary>
/// Update the normal history.
/// </summary>
/// <param name="currentNormal"></param>
private void UpdateGroundNormalHistory(Vector3 currentNormal)
{
// Update the current element of the history with the current normal
if (groundNormalHistoryLength > groundNormalHistoryIdx) { groundNormalHistory[groundNormalHistoryIdx] = currentNormal; }
// Keeps track of which array position to replace. Avoids having to shuffle elements
groundNormalHistoryIdx++;
if (groundNormalHistoryIdx >= groundNormalHistoryLength) { groundNormalHistoryIdx = 0; }
}
/// <summary>
/// Returns a damped max acceleration input.
/// </summary>
/// <param name="currentDisplacement"></param>
/// <param name="targetDisplacement"></param>
/// <param name="minDisplacement"></param>
/// <param name="maxDisplacement"></param>
/// <param name="minAcceleration"></param>
/// <param name="maxAcceleration"></param>
/// <param name="inputScalingFactor"></param>
/// <param name="inputPowerFactor"></param>
/// <returns></returns>
private float DampedMaxAccelerationInput(float currentDisplacement, float targetDisplacement, float minDisplacement,
float maxDisplacement, float minAcceleration, float maxAcceleration, float inputScalingFactor, float inputPowerFactor)
{
// Highest possible max acceleration input is max acceleration
float maxAccelerationInput = maxAcceleration;
// The max acceleration is determined by how close we are to the ground
// At the min/max allowed distance from the ground the limit is infinity
// At the target distance from the ground the limit is some given value
if (currentDisplacement < targetDisplacement && currentDisplacement > minDisplacement)
{
// Reciprocal
float xVal = (currentDisplacement - minDisplacement) / (targetDisplacement - minDisplacement);
maxAccelerationInput = minAcceleration + (inputScalingFactor * ((1f / Mathf.Pow(xVal, inputPowerFactor)) - 1f));
}
else if (currentDisplacement > targetDisplacement && currentDisplacement < maxDisplacement)
{
// Reciprocal
float xVal = (currentDisplacement - maxDisplacement) / (targetDisplacement - maxDisplacement);
maxAccelerationInput = minAcceleration + (inputScalingFactor * ((1f / Mathf.Pow(xVal, inputPowerFactor)) - 1f));
}
// Highest possible max acceleration input is max acceleration
return maxAccelerationInput < maxAcceleration ? maxAccelerationInput : maxAcceleration;
}
/// <summary>
/// Applies a specified amount of damage to the ship at a specified position.
/// </summary>
/// <param name="damageAmount"></param>
/// <param name="damagePosition"></param>
/// <param name="isCollisionDamage"></param>
private void ApplyDamage(float damageAmount, ProjectileModule.DamageType damageType, Vector3 damagePosition, bool adjustForCollisionResistance)
{
// Determine which damage region was hit
bool[] regionDamagedArray = new bool[1];
float[] actualDamageArray = new float[1];
int damageArrayLengths = 1;
if (shipDamageModel == ShipDamageModel.Localised)
{
damageArrayLengths = localisedDamageRegionList.Count + 1;
regionDamagedArray = new bool[damageArrayLengths];
actualDamageArray = new float[damageArrayLengths];
}
// Loop through all damage regions
DamageRegion thisDamageRegion;
float actualDamage = 0f;
bool regionDamaged = false;
bool isShipInvincible = mainDamageRegion.isInvincible;
// Get damage position in local space (calc once outside the loop)
Vector3 localDamagePosition = trfmInvRot * (damagePosition - trfmPos);
for (int i = 0; i < damageArrayLengths; i++)
{
// Get the current damage region we are iterating over, and work out whether it has been hit
if (i == 0)
{
// Main damage region
thisDamageRegion = mainDamageRegion;
// Main damage region is always hit unless it is invincible (which would make the whole ship invincible)
regionDamaged = !isShipInvincible;
}
else
{
// Localised damage region
thisDamageRegion = localisedDamageRegionList[i - 1];
// If the main damage region is invincible, so are all the damage regions
if (isShipInvincible || thisDamageRegion.isInvincible) { regionDamaged = false; }
else
{
// Calculate whether the hit point is within the volume, and hence populate regionDamaged variable
// First, get damage position in local space
//localDamagePosition = trfmInvRot * (damagePosition - trfmPos);
// Then check whether the position is within the bounds of this damage region
regionDamaged = thisDamageRegion.IsHit(localDamagePosition);
// For some reason we need to slightly expand the damage region when the collider is exactly the same size.
//regionDamaged = localDamagePosition.x >= thisDamageRegion.relativePosition.x - (thisDamageRegion.size.x / 2) - 0.0001f &&
// localDamagePosition.x <= thisDamageRegion.relativePosition.x + (thisDamageRegion.size.x / 2) + 0.0001f &&
// localDamagePosition.y >= thisDamageRegion.relativePosition.y - (thisDamageRegion.size.y / 2) - 0.0001f &&
// localDamagePosition.y <= thisDamageRegion.relativePosition.y + (thisDamageRegion.size.y / 2) + 0.0001f &&
// localDamagePosition.z >= thisDamageRegion.relativePosition.z - (thisDamageRegion.size.z / 2) - 0.0001f &&
// localDamagePosition.z <= thisDamageRegion.relativePosition.z + (thisDamageRegion.size.z / 2) + 0.0001f;
}
}
// Don't do any further calculations if the region wasn't hit
if (regionDamaged)
{
// Adjust for collision resistance - value passed in is just an impulse magnitude
if (adjustForCollisionResistance)
{
if (thisDamageRegion.collisionDamageResistance < 0.01f) { actualDamage = Mathf.Infinity; }
else { actualDamage = damageAmount / thisDamageRegion.collisionDamageResistance * 4f / mass; }
}
else { actualDamage = damageAmount; }
// Modify damage dealt based on relevant damage multipliers
if (useDamageMultipliers)
{
if (useLocalisedDamageMultipliers)
{
actualDamage *= thisDamageRegion.GetDamageMultiplier(damageType);
}
else
{
actualDamage *= mainDamageRegion.GetDamageMultiplier(damageType);
}
}
// Determine whether shielding is active for this damage region
if (thisDamageRegion.useShielding && thisDamageRegion.ShieldHealth > 0f)
{
// Set the shielding to active
regionDamaged = false;
// Only do damage to the shield if the damage amount is above the shielding threshold
if (actualDamage >= thisDamageRegion.shieldingDamageThreshold)
{
thisDamageRegion.ShieldHealth -= actualDamage;
thisDamageRegion.shieldRechargeDelayTimer = 0f;
// If this damage destroys the shielding entirely...
if (thisDamageRegion.ShieldHealth <= 0f)
{
// Get the residual damage value
actualDamage = -thisDamageRegion.ShieldHealth;
// Set the shielding to inactive
regionDamaged = true;
thisDamageRegion.ShieldHealth = -0.01f;
}
}
}
if (regionDamaged)
{
// Reduce health of damage region itself
thisDamageRegion.Health -= actualDamage;
}
}
// Added v1.2.7 - regions not damaged should have 0 damage
else { actualDamage = 0f; }
// Set calculated array variables
actualDamageArray[i] = actualDamage;
regionDamagedArray[i] = regionDamaged;
}
// Need to re-check this variable, as damage can destroy shielding and then use residual damage to affect
// the damage region as well
if (!shipDamageModelIsSimple && !isShipInvincible)
{
// Loop through each part list and reduce health of all parts in the regions that have been damaged
// Compute an index shift for localised damage regions
// Main damage region is index 0, so localised damage regions are a one-based indexing system
// as opposed to the standard zero-based indexing system
int drIndexShift = 0, drShiftedIndex, drIndex;
if (shipDamageModel == ShipDamageModel.Localised) { drIndexShift = 1; }
componentListSize = thrusterList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
drIndex = thrusterList[componentIndex].damageRegionIndex;
drShiftedIndex = drIndex + drIndexShift;
if (drIndex > -1 && drShiftedIndex < damageArrayLengths && regionDamagedArray[drShiftedIndex])
{
thrusterList[componentIndex].Health -= actualDamageArray[drShiftedIndex];
}
}
componentListSize = wingList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
drIndex = wingList[componentIndex].damageRegionIndex;
drShiftedIndex = drIndex + drIndexShift;
if (drIndex > -1 && drShiftedIndex < damageArrayLengths && regionDamagedArray[drShiftedIndex])
{
wingList[componentIndex].Health -= actualDamageArray[drShiftedIndex];
}
}
componentListSize = controlSurfaceList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
drIndex = controlSurfaceList[componentIndex].damageRegionIndex;
drShiftedIndex = drIndex + drIndexShift;
if (drIndex > -1 && drShiftedIndex < damageArrayLengths && regionDamagedArray[drShiftedIndex])
{
controlSurfaceList[componentIndex].Health -= actualDamageArray[drShiftedIndex];
}
}
componentListSize = weaponList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
drIndex = weaponList[componentIndex].damageRegionIndex;
drShiftedIndex = drIndex + drIndexShift;
if (drIndex > -1 && drShiftedIndex < damageArrayLengths && regionDamagedArray[drShiftedIndex])
{
weaponList[componentIndex].Health -= actualDamageArray[drShiftedIndex];
}
}
}
// Damage callback
if (callbackOnDamage != null) { callbackOnDamage(mainDamageRegion.Health); }
// Add a damage event
lastDamageEventIndex++;
// Calculate rumble and camera shake required
float rumbleDamageAmount = damageAmount;
if (adjustForCollisionResistance)
{
rumbleDamageAmount /= mainDamageRegion.collisionDamageResistance * 2500f;
}
// Start camera shake as damageAmount with adjusted collision amount if applicable
damageCameraShakeAmountRequired = rumbleDamageAmount;
if (rumbleDamageAmount <= minRumbleDamage) { damageRumbleAmountRequired = 0f; }
else if (rumbleDamageAmount >= maxRumbleDamage) { damageRumbleAmountRequired = 1f; }
else { damageRumbleAmountRequired = (rumbleDamageAmount - minRumbleDamage) / (maxRumbleDamage - minRumbleDamage); }
// Calculate camera shake required
if (damageCameraShakeAmountRequired < 0f) { damageCameraShakeAmountRequired = 0f; }
else if (damageCameraShakeAmountRequired > 1f) { damageCameraShakeAmountRequired = 1f; }
}
/// <summary>
/// Get the index or 0-based position in the list of damage regions.
/// Although typically used to return the index in the localisedDamageRegionList,
/// if passed the mainDamageRegion, it will always return 0.
/// If no matching regions are found, it will return -1.
/// </summary>
/// <param name="damageRegion"></param>
/// <returns></returns>
private int GetDamageRegionIndex(DamageRegion damageRegion)
{
int damageRegionIndex = -1;
if (damageRegion.guidHash == mainDamageRegion.guidHash) { return 0; }
else
{
int localisedDamageRegionListCount = localisedDamageRegionList == null ? 0 : localisedDamageRegionList.Count;
for (int drIdx = 0; drIdx < localisedDamageRegionListCount; drIdx++)
{
if (localisedDamageRegionList[drIdx].guidHash == damageRegion.guidHash) { damageRegionIndex = drIdx; break; }
}
}
return damageRegionIndex;
}
/// <summary>
/// Update the maximum estimated range for all turrets with auto targeting enabled
/// </summary>
internal void UpdateMaxTurretRange()
{
int numWeapons = weaponList == null ? 0 : weaponList.Count;
float maxRange = 0f;
for (int wpIdx = 0; wpIdx < numWeapons; wpIdx++)
{
Weapon weapon = weaponList[wpIdx];
// Only process turrets with Auto Targeting enabled
if (weapon != null && weapon.isAutoTargetingEnabled && (weapon.weaponTypeInt == Weapon.TurretProjectileInt || weapon.weaponTypeInt == Weapon.TurretBeamInt))
{
if (weapon.estimatedRange > maxRange) { maxRange = weapon.estimatedRange; }
}
}
estimatedMaxTurretRange = maxRange;
}
/// <summary>
/// Update the maximum estimated range for all weapons with auto targeting enabled
/// </summary>
internal void UpdateMaxAutoTargetRange()
{
int numWeapons = weaponList == null ? 0 : weaponList.Count;
float maxRange = 0f;
for (int wpIdx = 0; wpIdx < numWeapons; wpIdx++)
{
Weapon weapon = weaponList[wpIdx];
// Only process weapons with Auto Targeting enabled
if (weapon != null && weapon.isAutoTargetingEnabled)
{
if (weapon.estimatedRange > maxRange) { maxRange = weapon.estimatedRange; }
}
}
estimatedMaxAutoTargetRange = maxRange;
}
/// <summary>
/// This gets called from FixedUpdate in BeamModule. It performs the following:
/// 1. Checks if the beam should be despawned
/// 2. Moves the beam
/// 3. Changes the length
/// 4. Checks if it hits anything
/// 5. Updates damage on what it hits
/// 6. Instantiate effects object at hit point
/// 7. Consumes weapon power
/// It needs to be a member of the ship instance as it requires both ship and beam data.
/// Assumes the beam linerenderer has useWorldspace enabled.
/// </summary>
/// <param name="beamModule"></param>
internal void MoveBeam(BeamModule beamModule)
{
if (beamModule.isInitialised && beamModule.isBeamEnabled && beamModule.weaponIndex >= 0 && beamModule.firePositionIndex >= 0)
{
Weapon weapon = weaponList[beamModule.weaponIndex];
SSCBeamItemKey beamItemKey = weapon.beamItemKeyList[beamModule.firePositionIndex];
// Read once from the deltaTime property getter
float _deltaTime = Time.deltaTime;
if ((weapon.weaponTypeInt == Weapon.FixedBeamInt || weapon.weaponTypeInt == Weapon.TurretBeamInt) && beamItemKey.beamSequenceNumber == beamModule.itemSequenceNumber)
{
weaponFiringButtonInt = (int)weapon.firingButton;
// For autofiring weapons, this will return false.
bool isReadyToFire = (pilotPrimaryFireInput && weaponFiringButtonInt == weaponPrimaryFiringInt) || (pilotSecondaryFireInput && weaponFiringButtonInt == weaponSecondaryFiringInt);
// If this is auto-firing turret check if it is ready to fire
if (weaponFiringButtonInt == weaponAutoFiringInt && weapon.weaponTypeInt == Weapon.TurretBeamInt)
{
// Is turret locked on target and in direct line of sight?
// NOTE: If check LoS is enabled, it will still fire if another enemy is between the turret and the weapon.target.
isReadyToFire = weapon.isLockedOnTarget && (!weapon.checkLineOfSight || WeaponHasLineOfSight(weapon));
// BUILD TEST
//isReadyToFire = !weapon.checkLineOfSight || WeaponHasLineOfSight(weapon);
// TODO - Is target in range?
}
// Should this beam be despawned or returned to the pool?
// a) No charge in weapon
// b) Weapon has no health
// c) Weapon has no performance
// d) user stopped firing and has fired for min time permitted
// e) has exceeded the maximum firing duration
if (weapon.chargeAmount <= 0f || weapon.health <= 0f || weapon.currentPerformance == 0f || (!isReadyToFire && beamModule.burstDuration > beamModule.minBurstDuration) || beamModule.burstDuration > beamModule.maxBurstDuration)
{
// Unassign the beam from this weapon's fire position
weapon.beamItemKeyList[beamModule.firePositionIndex] = new SSCBeamItemKey(-1, -1, 0);
beamModule.DestroyBeam();
}
else
{
// Move the beam start
// Calculate the World-space Fire Position (like when weapon is first fired)
// Note: That the ship could have moved and rotated, so we recalc here.
Vector3 _weaponWSBasePos = GetWeaponWorldBasePosition(weapon);
Vector3 _weaponWSFireDir = GetWeaponWorldFireDirection(weapon);
Vector3 _weaponWSFirePos = GetWeaponWorldFirePosition(weapon, _weaponWSBasePos, beamModule.firePositionIndex);
// Move the beam transform but keep the first LineRenderer position at 0,0,0
beamModule.transform.position = _weaponWSFirePos;
beamModule.transform.SetPositionAndRotation(_weaponWSFirePos, Quaternion.LookRotation(_weaponWSFireDir, rbodyUp));
// Calc length and end position
float _desiredLength = beamModule.burstDuration * beamModule.speed;
if (_desiredLength > weapon.maxRange) { _desiredLength = weapon.maxRange; }
Vector3 _endPosition = _weaponWSFirePos + (_weaponWSFireDir * _desiredLength);
// Check if it hit anything
if (Physics.Linecast(_weaponWSFirePos, _endPosition, out raycastHitInfo, ~0, QueryTriggerInteraction.Ignore))
{
// Adjust the end position to the hit point
_endPosition = raycastHitInfo.point;
// Update damage if it hit a ship or an object with a damage receiver
if (!BeamModule.CheckShipHit(raycastHitInfo, beamModule, _deltaTime))
{
// If it hit an object with a DamageReceiver script attached, take appropriate action like call a custom method
BeamModule.CheckObjectHit(raycastHitInfo, beamModule, _deltaTime);
}
// ISSUES - the effect may not be visible while firing if:
// 1) if the effect despawn time is less than the beam max burst duration (We have a warning in the BeamModule editor)
// 2) if the effect does not have looping enabled (this could be more expensive to check)
// Add or Move the effects object
if (beamModule.effectsObjectPrefabID >= 0)
{
if (sscManager == null) { sscManager = SSCManager.GetOrCreateManager(); }
if (sscManager != null)
{
// If the effect has not been spawned, do now
if (beamModule.effectsItemKey.effectsObjectSequenceNumber == 0)
{
InstantiateEffectsObjectParameters ieParms = new InstantiateEffectsObjectParameters
{
effectsObjectPrefabID = beamModule.effectsObjectPrefabID,
position = _endPosition,
rotation = beamModule.transform.rotation
};
// Instantiate the hit effects
if (sscManager.InstantiateEffectsObject(ref ieParms) != null)
{
if (ieParms.effectsObjectSequenceNumber > 0)
{
// Record the hit effect item key
beamModule.effectsItemKey = new SSCEffectItemKey(ieParms.effectsObjectPrefabID, ieParms.effectsObjectPoolListIndex, ieParms.effectsObjectSequenceNumber);
}
}
}
// Move the existing effects object to the end of the beam
else
{
// Currently we are not checking sequence number matching (for pooled effects) as it is faster and can
// avoid doing an additional GetComponent().
sscManager.MoveEffectsObject(beamModule.effectsItemKey, _endPosition, beamModule.transform.rotation, false);
}
}
}
}
// The beam isn't hitting anything AND there is an active effects object
else if (beamModule.effectsObjectPrefabID >= 0 && beamModule.effectsItemKey.effectsObjectSequenceNumber > 0)
{
// Destroy the effects object or return it to the pool
if (sscManager == null) { sscManager = SSCManager.GetOrCreateManager(); }
if (sscManager != null)
{
sscManager.DestroyEffectsObject(beamModule.effectsItemKey);
}
}
// Move the beam end (assumes world space)
// useWorldspace is enabled in beamModule.InitialiseBeam(..)
beamModule.lineRenderer.SetPosition(0, _weaponWSFirePos);
beamModule.lineRenderer.SetPosition(1, _endPosition);
// Consume weapon power. Consumes upt to 2x power when overheating.
if (weapon.rechargeTime > 0f) { weapon.chargeAmount -= _deltaTime * (weapon.heatLevel > weapon.overHeatThreshold ? 2f - weapon.currentPerformance : 1f) / beamModule.dischargeDuration; }
weapon.ManageHeat(_deltaTime, 1f);
// If we run out of power, de-activate it before weapon starts recharging
if (weapon.chargeAmount <= 0f)
{
weapon.chargeAmount = 0f;
// Unassign the beam from this weapon's fire position
weapon.beamItemKeyList[beamModule.firePositionIndex] = new SSCBeamItemKey(-1, -1, 0);
beamModule.DestroyBeam();
}
}
}
}
#if UNITY_EDITOR
else { Debug.LogWarning("ERROR ship.MoveBeam has been called on the wrong beam. isInitialised: " + beamModule.isInitialised +
" isBeamEnabled: " + beamModule.isBeamEnabled + " weaponIndex: " + beamModule.weaponIndex + " firePositionIndex: " + beamModule.firePositionIndex); }
#endif
}
private Vector3 GetWeaponWorldBasePosition(Weapon weapon)
{
return (trfmRight * weapon.relativePosition.x) +
(trfmUp * weapon.relativePosition.y) +
(trfmFwd * weapon.relativePosition.z) +
trfmPos;
}
private Vector3 GetWeaponWorldFireDirection(Weapon weapon)
{
// Get relative fire direction
weaponRelativeFireDirection = weapon.fireDirectionNormalised;
// If this is a turret, adjust relative fire direction based on turret rotation
if (weapon.weaponTypeInt == Weapon.TurretProjectileInt || weapon.weaponTypeInt == Weapon.TurretBeamInt)
{
// (turret rotation less ship rotate) - (original turret rotation less ship rotation) + relative fire direction
weaponRelativeFireDirection = (trfmInvRot * weapon.turretPivotX.rotation) * weapon.intPivotYInvRot * weaponRelativeFireDirection;
}
// Get weapon world fire direction
return (trfmRight * weaponRelativeFireDirection.x) +
(trfmUp * weaponRelativeFireDirection.y) +
(trfmFwd * weaponRelativeFireDirection.z);
}
private Vector3 GetWeaponWorldFirePosition(Weapon weapon, Vector3 weaponWorldBasePosition, int firePositionIndex)
{
// Check if there are multiple fire positions
if (weapon.isMultipleFirePositions)
{
// Get relative fire position
weaponRelativeFirePosition = weapon.firePositionList[firePositionIndex];
}
else
{
// If there is only one fire position, relative position must be the zero vector
weaponRelativeFirePosition.x = 0f;
weaponRelativeFirePosition.y = 0f;
weaponRelativeFirePosition.z = 0f;
}
// If this is a turret, adjust relative fire position based on turret rotation
if (weapon.weaponTypeInt == Weapon.TurretProjectileInt || weapon.weaponTypeInt == Weapon.TurretBeamInt)
{
weaponRelativeFirePosition = (trfmInvRot * weapon.turretPivotX.rotation) * weaponRelativeFirePosition;
}
return weaponWorldBasePosition +
(trfmRight * weaponRelativeFirePosition.x) +
(trfmUp * weaponRelativeFirePosition.y) +
(trfmFwd * weaponRelativeFirePosition.z);
}
/// <summary>
/// Begin to shut down the thrusters. Optionally override the shutdown duration.
/// See also shipControlModule.ShutdownThrusterSystems(..)
/// </summary>
internal void ShutdownThrusterSystems (bool isInstantShutdown = false)
{
// Instant shutdown can be called even while in the process of shutting down.
if (isThrusterSystemsStarted || isInstantShutdown)
{
// Perform an instant shutdown?
if (isInstantShutdown || thrusterSystemShutdownDuration <= 0f)
{
isThrusterSystemsStarted = false;
thrusterSystemShutdownTimer = 0f;
thrusterSystemStartupTimer = 0f;
SetThrottleAllThrusters(0f);
}
else
{
// Activate the shutdown sequence
// if startup was in progress, begin at that point
if (thrusterSystemStartupTimer > 0f && thrusterSystemStartupDuration > 0f)
{
thrusterSystemShutdownTimer = (1f - (thrusterSystemStartupTimer / thrusterSystemStartupDuration)) * thrusterSystemShutdownDuration;
}
else
{
thrusterSystemShutdownTimer = 0.001f;
}
// Reset the startup timer so that shutdown can continue
thrusterSystemStartupTimer = 0f;
}
}
}
/// <summary>
/// Begin to bring the thrusters online. Optionally, override the startup duration.
/// As soon as the systems begin to start up, isThrusterSystemsStarted will be true.
/// See also shipControlModule.StartupThrusterSystems(..)
/// </summary>
internal void StartupThrusterSystems (bool isInstantStartup = false)
{
// Instant startup can be called even while in the process of
// starting up. This is actually how we trigger the end of the
// startup process when the timer expires in CheckThrusterSystems(..).
// Perform an instant startup?
if (isInstantStartup || thrusterSystemStartupDuration <= 0f)
{
thrusterSystemShutdownTimer = 0f;
thrusterSystemStartupTimer = 0f;
SetThrottleAllThrusters(1f);
}
else
{
// Activate the startup sequence
// if shutdown was in progress, begin at that point
if (thrusterSystemShutdownTimer > 0f && thrusterSystemShutdownDuration > 0f)
{
thrusterSystemStartupTimer = (1f - (thrusterSystemShutdownTimer / thrusterSystemShutdownDuration)) * thrusterSystemStartupDuration;
}
else
{
thrusterSystemStartupTimer = 0.001f;
}
// Reset the shutdown timer so that startup can continue
thrusterSystemShutdownTimer = 0f;
}
isThrusterSystemsStarted = true;
}
#endregion
#region Public Non-Static Methods
#region Set Class Defaults
public void SetClassDefaults()
{
this.initialiseOnAwake = true;
this.shipPhysicsModel = ShipPhysicsModel.Arcade;
this.mass = 5000f;
this.centreOfMass = Vector3.zero;
this.setCentreOfMassManually = false;
this.showCOMGizmosInSceneView = true;
this.showCOLGizmosInSceneView = false;
this.showCOTGizmosInSceneView = false;
this.thrusterList = new List<Thruster>(25);
// Create a default forwards-facing thruster
Thruster thruster = new Thruster();
if (thruster != null)
{
thruster.name = "Forward Thruster";
thruster.forceUse = 1;
thruster.primaryMomentUse = 0;
thruster.secondaryMomentUse = 0;
thruster.maxThrust = 100000;
thruster.thrustDirection = Vector3.forward;
thruster.relativePosition = Vector3.zero;
this.thrusterList.Add(thruster);
}
isThrusterFXStationary = false;
isThrusterSystemsStarted = true;
thrusterSystemStartupDuration = 5f;
thrusterSystemShutdownDuration = 5f;
useCentralFuel = true;
centralFuelLevel = 100f;
this.wingList = new List<Wing>(5);
this.controlSurfaceList = new List<ControlSurface>(10);
this.weaponList = new List<Weapon>(10);
// Expand editor lists by default
isThrusterSystemsExpanded = true;
isThrusterListExpanded = true;
isWingListExpanded = true;
isControlSurfaceListExpanded = true;
isWeaponListExpanded = true;
isDamageListExpanded = true;
isMainDamageExpanded = true;
showDamageInEditor = true;
this.dragCoefficients = new Vector3(0.5f, 1f, 0.1f);
this.dragReferenceAreas = new Vector3(10f, 20f, 5f);
this.centreOfDragXMoment = Vector3.zero;
this.centreOfDragYMoment = Vector3.zero;
this.centreOfDragZMoment = Vector3.zero;
this.angularDragFactor = 1f;
this.disableDragMoments = false;
this.dragXMomentMultiplier = 1f;
this.dragYMomentMultiplier = 1f;
this.dragZMomentMultiplier = 1f;
this.wingStallEffect = 1f;
this.arcadeUseBrakeComponent = true;
this.arcadeBrakeStrength = 100f;
this.arcadeBrakeIgnoreMediumDensity = false;
this.arcadeBrakeMinAcceleration = 25f;
this.rotationalFlightAssistStrength = 3f;
this.translationalFlightAssistStrength = 3f;
this.stabilityFlightAssistStrength = 0f;
this.brakeFlightAssistStrength = 0f;
this.brakeFlightAssistMinSpeed = -10f;
this.brakeFlightAssistMaxSpeed = 10f;
this.limitPitchAndRoll = false;
this.maxPitch = 10f;
this.maxTurnRoll = 15f;
this.pitchSpeed = 30f;
this.turnRollSpeed = 30f;
this.rollControlMode = RollControlMode.YawInput;
this.pitchRollMatchResponsiveness = 4f;
this.stickToGroundSurface = false;
this.avoidGroundSurface = false;
this.useGroundMatchSmoothing = false;
this.useGroundMatchLookAhead = false;
this.orientUpInAir = false;
this.targetGroundDistance = 5f;
this.minGroundDistance = 2f;
this.maxGroundDistance = 8f;
this.maxGroundCheckDistance = 25f;
this.groundMatchResponsiveness = 50f;
this.groundMatchDamping = 50f;
this.maxGroundMatchAccelerationFactor = 3f;
this.centralMaxGroundMatchAccelerationFactor = 1f;
this.groundNormalCalculationMode = GroundNormalCalculationMode.SmoothedNormal;
this.groundNormalHistoryLength = 5;
this.groundLayerMask = ~0;
this.inputControlAxis = InputControlAxis.None;
this.inputControlLimit = 0f;
this.inputControlForwardAngle = 0f;
this.inputControlMovingRigidness = 25f;
this.inputControlTurningRigidness = 25f;
this.rollPower = 1f;
this.pitchPower = 1f;
this.yawPower = 1f;
this.steeringThrusterPriorityLevel = 0f;
this.pilotMomentInput = Vector3.zero;
this.pilotForceInput = Vector3.zero;
this.arcadePitchAcceleration = 100f;
this.arcadeYawAcceleration = 100f;
this.arcadeRollAcceleration = 250f;
this.arcadeMaxFlightTurningAcceleration = 500f;
this.arcadeMaxGroundTurningAcceleration = 500f;
this.mediumDensity = 1.293f;
this.gravitationalAcceleration = 9.81f;
this.gravityDirection = -Vector3.up;
this.shipDamageModel = ShipDamageModel.Simple;
this.mainDamageRegion = new DamageRegion();
this.mainDamageRegion.name = "Main Damage Region";
this.localisedDamageRegionList = new List<DamageRegion>(10);
this.useDamageMultipliers = false;
this.useLocalisedDamageMultipliers = false;
this.respawnTime = 5f;
this.collisionRespawnPositionDelay = 5f;
this.respawningMode = RespawningMode.DontRespawn;
this.customRespawnPosition = Vector3.zero;
this.customRespawnRotation = Vector3.zero;
this.respawnVelocity = Vector3.zero;
this.respawningPathGUIDHash = 0;
this.minRumbleDamage = 0f;
this.maxRumbleDamage = 10f;
this.stuckTime = 0f;
this.stuckSpeedThreshold = 0.1f;
this.stuckAction = StuckAction.DoNothing;
this.stuckActionPathGUIDHash = 0;
// By default, all ships on the same faction/side/alliance.
this.factionId = 0;
squadronId = -1; // NOT SET
this.isRadarEnabled = false;
this.radarBlipSize = 1;
}
#endregion
#region Initialisation
/// <summary>
/// Initialise all necessary ship data.
/// </summary>
public void Initialise(Transform trfm)
{
// Store physics model as a boolean value to save looking up enumeration at runtime
shipPhysicsModelPhysicsBased = shipPhysicsModel == ShipPhysicsModel.PhysicsBased;
// New values, better for pipes
pitchPIDController = new PIDController(0.5f, 0f, 0.1f);
rollPIDController = new PIDController(0.5f, 0f, 0.1f);
// For pitch and roll derivative on measurement is disabled so that
// a) in limit pitch/roll mode we can use local-space pitch and roll measurements
// b) if the target pitch/roll is quickly moving away from the measured pitch/roll the
// PID controller can use a large input to prevent it
pitchPIDController.derivativeOnMeasurement = false;
rollPIDController.derivativeOnMeasurement = false;
ReinitialisePitchRollMatchVariables();
// Create a new PID controller for ground match
groundDistPIDController = new PIDController(0f, 0f, 0f);
// For ground dist derivative on measurement is disabled so that if the target distance is quickly moving away from
// the measured pitch/roll the PID controller can use a large input to prevent it
groundDistPIDController.derivativeOnMeasurement = false;
// Initialise ground dist PID controller variables
ReinitialiseGroundMatchVariables();
// Create new PID controllers for input axis control
inputAxisForcePIDController = new PIDController(0f, 0f, 0f);
inputAxisMomentPIDController = new PIDController(0f, 0f, 0f);
inputAxisForcePIDController.derivativeOnMeasurement = false;
inputAxisMomentPIDController.derivativeOnMeasurement = false;
ReinitialiseInputControlVariables();
// Create new PID controllers for stability flight assist
sFlightAssistPitchPIDController = new PIDController(0f, 0f, 0f);
sFlightAssistYawPIDController = new PIDController(0f, 0f, 0f);
sFlightAssistRollPIDController = new PIDController(0f, 0f, 0f);
ReinitialiseStabilityFlightAssistVariables();
// Initialise ray for raycasting against the ground
raycastRay = new Ray(Vector3.zero, Vector3.up);
// Initialise thruster, wing, weapon and damage region variables
ReinitialiseThrusterVariables();
ReinitialiseWingVariables();
ReinitialiseWeaponVariables();
ReinitialiseDamageRegionVariables(true);
// Cache the Weapon FiringButton enumeration values to avoid looking up the enumeration
// Used in CalculateForceAndMoment(..)
weaponPrimaryFiringInt = (int)Weapon.FiringButton.Primary;
weaponSecondaryFiringInt = (int)Weapon.FiringButton.Secondary;
weaponAutoFiringInt = (int)Weapon.FiringButton.AutoFire;
// Initialise respawn data
ReinitialiseRespawnVariables();
// Initialise input data
ReinitialiseInputVariables();
// Get a ship ID integer from the transform ID
shipId = trfm.GetInstanceID();
// Initially there is no radar item assigned in the radar system
radarItemIndex = -1;
// Added in 1.3.3 for muzzle FX reparenting ONLY.
// Use with caution as may need to be removed in the future if
// causes issues like when destroying the ShipControlModule.
shipTransform = trfm;
StopBoost();
}
/// <summary>
/// Re-initialises all variables needed when changing the ship physics model.
/// Call after modifying shipPhysicsModel.
/// </summary>
public void ReinitialiseShipPhysicsModel()
{
// Store physics model as a boolean value to save looking up enumeration at runtime
shipPhysicsModelPhysicsBased = shipPhysicsModel == ShipPhysicsModel.PhysicsBased;
ReinitialisePitchRollMatchVariables();
ReinitialiseGroundMatchVariables();
ReinitialiseInputVariables();
ReinitialiseInputControlVariables();
}
/// <summary>
/// Re-initialises variables related to the stability flight assist.
/// Call after modifying stabilityFlightAssistStrength.
/// </summary>
private void ReinitialiseStabilityFlightAssistVariables()
{
// Configure pitch PID controller
sFlightAssistPitchPIDController.pGain = 0.025f * stabilityFlightAssistStrength;
sFlightAssistPitchPIDController.iGain = 0.005f * stabilityFlightAssistStrength;
sFlightAssistPitchPIDController.dGain = 0.01f * stabilityFlightAssistStrength;
sFlightAssistPitchPIDController.SetInputLimits(-1f, 1f);
// Configure yaw PID controller
sFlightAssistYawPIDController.pGain = 0.025f * stabilityFlightAssistStrength;
sFlightAssistYawPIDController.iGain = 0.005f * stabilityFlightAssistStrength;
sFlightAssistYawPIDController.dGain = 0.01f * stabilityFlightAssistStrength;
sFlightAssistYawPIDController.SetInputLimits(-1f, 1f);
// Configure roll PID controller
sFlightAssistRollPIDController.pGain = 0.025f * stabilityFlightAssistStrength;
sFlightAssistRollPIDController.iGain = 0.005f * stabilityFlightAssistStrength;
sFlightAssistRollPIDController.dGain = 0.01f * stabilityFlightAssistStrength;
sFlightAssistRollPIDController.SetInputLimits(-1f, 1f);
}
/// <summary>
/// Re-initialises variables related to pitch and roll match.
/// </summary>
private void ReinitialisePitchRollMatchVariables()
{
if (shipPhysicsModelPhysicsBased)
{
// Pitch and roll PID controllers are always constrained to ship physics
pitchPIDController.SetInputLimits(-1f, 1f);
rollPIDController.SetInputLimits(-1f, 1f);
}
else
{
// Pitch and roll PID controllers are not constrained to ship physics
pitchPIDController.SetInputLimits(Mathf.NegativeInfinity, Mathf.Infinity);
rollPIDController.SetInputLimits(Mathf.NegativeInfinity, Mathf.Infinity);
}
// Reset PID controllers
pitchPIDController.ResetController();
rollPIDController.ResetController();
}
/// <summary>
/// Re-initialises variables related to ground distance match calculations.
/// Call after modifying useGroundMatchSmoothing, groundMatchResponsiveness, groundMatchDamping,
/// maxGroundMatchAccelerationFactor, centralMaxGroundMatchAccelerationFactor or groundNormalHistoryLength.
/// </summary>
public void ReinitialiseGroundMatchVariables()
{
// Calculate height range constant (if we are using a min-max range for target distance)
float groundMatchHeightRangeConstant = 10f;
if (useGroundMatchSmoothing)
{
// Set the constant to the minimum of: The difference between the min and target distances and the difference
// between the max and target distances
groundMatchHeightRangeConstant = targetGroundDistance - minGroundDistance;
if (groundMatchHeightRangeConstant > maxGroundDistance - targetGroundDistance)
{
groundMatchHeightRangeConstant = maxGroundDistance - targetGroundDistance;
}
}
// P-gain is proportional to responsiveness and inversely proportional to height range
groundDistPIDController.pGain = 100f * groundMatchResponsiveness / groundMatchHeightRangeConstant;
// I-gain is half of p-gain
groundDistPIDController.iGain = 50f * groundMatchResponsiveness / groundMatchHeightRangeConstant;
// D-gain is proportional to damping and inversely proportional to height range
groundDistPIDController.dGain = 10f * groundMatchDamping / groundMatchHeightRangeConstant;
if (shipPhysicsModelPhysicsBased)
{
// In physics-based mode, the forces must stay within the limits of the ship thrusters
groundDistPIDController.SetInputLimits(-1f, 1f);
}
else
{
// In arcade mode, the forces must stay within a maximum acceleration
maxGroundMatchAcceleration = Mathf.Pow(10f, maxGroundMatchAccelerationFactor);
groundDistPIDController.SetInputLimits(-maxGroundMatchAcceleration, maxGroundMatchAcceleration);
centralMaxGroundMatchAcceleration = Mathf.Pow(10f, centralMaxGroundMatchAccelerationFactor);
}
// Reset the PID Controller
groundDistPIDController.ResetController();
// Initialise ground normal history
groundNormalHistory = new Vector3[groundNormalHistoryLength];
for (int gnIdx = 0; gnIdx < groundNormalHistoryLength; gnIdx++) { groundNormalHistory[gnIdx] = trfmUp; }
}
/// <summary>
/// Re-initialises variables related to Input Control for 2.5D flight.
/// Call this after modifying inputControlAxis, inputControlMovingRigidness or inputControlTurningRigidness.
/// </summary>
public void ReinitialiseInputControlVariables()
{
if (shipPhysicsModelPhysicsBased)
{
// Set up the physics-based movement PID controller
// 0.5, 0.1, 0.1 TODO tweak for physics-based
inputAxisForcePIDController.pGain = inputControlMovingRigidness * 0.1f;
inputAxisForcePIDController.iGain = inputControlMovingRigidness * 0.02f;
inputAxisForcePIDController.dGain = inputControlMovingRigidness * 0.02f;
// Set up the physics-base rotation PID controller
// 10, 2, 2 TODO tweak for physics-based
inputAxisMomentPIDController.pGain = inputControlTurningRigidness * 1f;
inputAxisMomentPIDController.iGain = inputControlTurningRigidness * 0.2f;
inputAxisMomentPIDController.dGain = inputControlTurningRigidness * 0.2f;
// Set physical input limits
inputAxisForcePIDController.SetInputLimits(-1f, 1f);
inputAxisMomentPIDController.SetInputLimits(-1f, 1f);
}
else
{
// Set up the arcade movement PID controller
inputAxisForcePIDController.pGain = inputControlMovingRigidness * 1f;
inputAxisForcePIDController.iGain = inputControlMovingRigidness * 0.2f;
inputAxisForcePIDController.dGain = inputControlMovingRigidness * 0.2f;
// Set up the arcade rotation PID controller
inputAxisMomentPIDController.pGain = inputControlTurningRigidness * 1f;
inputAxisMomentPIDController.iGain = inputControlTurningRigidness * 0.2f;
inputAxisMomentPIDController.dGain = inputControlTurningRigidness * 0.2f;
// Set non-physical input limits
inputAxisForcePIDController.SetInputLimits(Mathf.NegativeInfinity, Mathf.Infinity);
inputAxisMomentPIDController.SetInputLimits(Mathf.NegativeInfinity, Mathf.Infinity);
}
inputAxisForcePIDController.ResetController();
inputAxisMomentPIDController.ResetController();
}
/// <summary>
/// Re-initialises variables related to thrusters.
/// Call after modifying thrusterList.
/// </summary>
public void ReinitialiseThrusterVariables()
{
// Initialise all thrusters
componentListSize = thrusterList == null ? 0 : thrusterList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
thrusterList[componentIndex].Initialise();
}
// If thruster systems are not online, immediately turn off all thrusters.
if (!isThrusterSystemsStarted)
{
ShutdownThrusterSystems(true);
}
}
/// <summary>
/// Re-initialises variables related to wings.
/// Call after modifying wingList.
/// </summary>
public void ReinitialiseWingVariables()
{
// Initialise all wings
componentListSize = wingList == null ? 0 : wingList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
wingList[componentIndex].Initialise();
}
}
/// <summary>
/// Re-initialises variables related to weapons.
/// Call after modifying weaponList.
/// </summary>
public void ReinitialiseWeaponVariables()
{
// Initialise all weapons
componentListSize = weaponList == null ? 0 : weaponList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
weaponList[componentIndex].Initialise(trfmInvRot);
}
}
/// <summary>
/// Re-initialises variables related to damage regions.
/// Call after modifying mainDamageRegion or localDamageRegionList (or modifying shipDamageModel).
/// NOTE: Not required if just changing the Health or ShieldHealth
/// </summary>
public void ReinitialiseDamageRegionVariables(bool refreshAll = false)
{
// Initialise the main damage region
mainDamageRegion.Initialise();
numLocalisedDamageRegions = 0;
// Only initialise localised damage regions if the ship damage model is localised
if (shipDamageModel == ShipDamageModel.Localised || refreshAll)
{
// Initialise all localised damage regions
numLocalisedDamageRegions = localisedDamageRegionList == null ? 0 : localisedDamageRegionList.Count;
for (componentIndex = 0; componentIndex < numLocalisedDamageRegions; componentIndex++)
{
localisedDamageRegionList[componentIndex].Initialise();
}
}
}
/// <summary>
/// Re-initialises respawn variables using the current position and rotation of the ship.
/// Also needs to be called after changing respawningMode to RespawningMode.RespawnAtLastPosition.
/// </summary>
public void ReinitialiseRespawnVariables()
{
// Initialise current respawn position/rotation
currentRespawnPosition = trfmPos;
currentRespawnRotation = trfmRot;
if (respawningMode == RespawningMode.RespawnAtLastPosition)
{
currentCollisionRespawnPosition = currentRespawnPosition;
currentCollisionRespawnRotation = currentRespawnRotation;
nextCollisionRespawnPosition = currentRespawnPosition;
nextCollisionRespawnRotation = currentRespawnRotation;
}
}
/// <summary>
/// Re-initialises variables related to ship inputs.
/// Call after modifying thrusterList or controlSurfaceList.
/// Call after modifying the forceUse/primaryMomentUse/secondaryMomentUse of a thruster or the type of a control surface.
/// </summary>
public void ReinitialiseInputVariables()
{
// Initially assume that no inputs are used
longitudinalThrustInputUsed = false;
horizontalThrustInputUsed = false;
verticalThrustInputUsed = false;
pitchMomentInputUsed = false;
yawMomentInputUsed = false;
rollMomentInputUsed = false;
if (shipPhysicsModelPhysicsBased)
{
// Loop through all thrusters to check force and moment inputs
componentListSize = thrusterList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
// Get the thruster we are concerned with
thruster = thrusterList[componentIndex];
// Check whether force inputs are used for this thruster
if (thruster.forceUse == 1 || thruster.forceUse == 2) { longitudinalThrustInputUsed = true; }
else if (thruster.forceUse == 3 || thruster.forceUse == 4) { verticalThrustInputUsed = true; }
else if (thruster.forceUse == 5 || thruster.forceUse == 6) { horizontalThrustInputUsed = true; }
// Check whether moment inputs are used for this thruster
if (thruster.primaryMomentUse == 1 || thruster.primaryMomentUse == 2) { rollMomentInputUsed = true; }
else if (thruster.primaryMomentUse == 3 || thruster.primaryMomentUse == 4) { pitchMomentInputUsed = true; }
else if (thruster.primaryMomentUse == 5 || thruster.primaryMomentUse == 6) { yawMomentInputUsed = true; }
if (thruster.secondaryMomentUse == 1 || thruster.secondaryMomentUse == 2) { rollMomentInputUsed = true; }
else if (thruster.secondaryMomentUse == 3 || thruster.secondaryMomentUse == 4) { pitchMomentInputUsed = true; }
else if (thruster.secondaryMomentUse == 5 || thruster.secondaryMomentUse == 6) { yawMomentInputUsed = true; }
}
// Loop through all control surfaces to check moment inputs and brake input
componentListSize = controlSurfaceList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
// Get the control surface we are concerned with
controlSurface = controlSurfaceList[componentIndex];
// Check whether moment inputs are used for this control surface
if (controlSurface.type == ControlSurface.ControlSurfaceType.Aileron) { rollMomentInputUsed = true; }
else if (controlSurface.type == ControlSurface.ControlSurfaceType.Elevator) { pitchMomentInputUsed = true; }
else if (controlSurface.type == ControlSurface.ControlSurfaceType.Rudder) { yawMomentInputUsed = true; }
else if (controlSurface.type == ControlSurface.ControlSurfaceType.AirBrake) { longitudinalThrustInputUsed = true; }
}
}
else
{
// Loop through all thrusters to check force inputs
componentListSize = thrusterList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
// Get the thruster we are concerned with
thruster = thrusterList[componentIndex];
// Check whether force inputs are used for this thruster
if (thruster.forceUse == 1 || thruster.forceUse == 2) { longitudinalThrustInputUsed = true; }
else if (thruster.forceUse == 3 || thruster.forceUse == 4) { verticalThrustInputUsed = true; }
else if (thruster.forceUse == 5 || thruster.forceUse == 6) { horizontalThrustInputUsed = true; }
}
// In arcade mode, moment inputs only depend on the pitch/roll/yaw accelerations being non-zero
pitchMomentInputUsed = arcadePitchAcceleration > 0.01f;
yawMomentInputUsed = arcadeYawAcceleration > 0.01f;
rollMomentInputUsed = arcadeRollAcceleration > 0.01f;
// In arcade mode, brakes can count for longitudinal inputs
if (arcadeUseBrakeComponent) { longitudinalThrustInputUsed = true; }
}
}
#endregion
#region Update Position And Movement Data
/// <summary>
/// Reset the cached velocity data. Typically called
/// when the ship rigidbody is set to kinematic.
/// </summary>
public void ResetVelocityData()
{
worldVelocity = Vector3.zero;
localVelocity = Vector3.zero;
absLocalVelocity = Vector3.zero;
worldAngularVelocity = Vector3.zero;
localAngularVelocity = Vector3.zero;
}
/// <summary>
/// Update position and movement data using data obtained from a transform and a rigidbody.
/// </summary>
/// <param name="transform"></param>
/// <param name="rigidbody"></param>
public void UpdatePositionAndMovementData(Transform transform, Rigidbody rigidbody)
{
// Update data obtained from transform
trfmPos = transform.position;
trfmFwd = transform.forward;
trfmRight = transform.right;
trfmUp = transform.up;
trfmRot = transform.rotation;
trfmInvRot = Quaternion.Inverse(trfmRot);
// Update data obtained from rigidbody
rbodyPos = rigidbody.position;
rbodyRot = rigidbody.rotation;
rbodyInvRot = Quaternion.Inverse(rbodyRot);
rbodyFwd = rbodyRot * Vector3.forward;
rbodyRight = rbodyRot * Vector3.right;
rbodyUp = rbodyRot * Vector3.up;
worldVelocity = rigidbody.velocity;
worldAngularVelocity = rigidbody.angularVelocity;
localVelocity = rbodyInvRot * worldVelocity;
localAngularVelocity = rbodyInvRot * worldAngularVelocity;
rBodyInertiaTensor = rigidbody.inertiaTensor;
}
#endregion
#region Calculate Force and Moment
/// <summary>
/// Calculate the equivalent local resultant force and moment for the ship and store them in the supplied reference vectors.
/// Should be called during FixedUpdate(), and have UpdatePositionAndMovementData() called prior to it.
/// </summary>
/// <param name="localResultantForce"></param>
/// <param name="localResultantMoment"></param>
public void CalculateForceAndMoment(ref Vector3 localResultantForce, ref Vector3 localResultantMoment)
{
#if SSC_SHIP_DEBUG
float initStartTime = Time.realtimeSinceStartup;
#endif
// TODO: OPTIMISATIONS
// Reduce number of function calls
// Use less math functions
// Remove variable declarations
// Try not to use transform functions and vector3 functions
// Do as much precalculation as possible i.e. store a bool for isPhysicsBased etc.
#region Initialisation
// Read from Time property getter once
float _deltaTime = Time.deltaTime;
// Remember the previous frame's world velocity
previousFrameWorldVelocity = worldVelocity;
// Reset local resultant force and moment
localResultantForce = Vector3.zero;
localResultantMoment = Vector3.zero;
// Reset any inputs that aren't used (forceInput and momentInput variables used temporarily)
forceInput.x = horizontalThrustInputUsed ? pilotForceInput.x : 0f;
forceInput.y = verticalThrustInputUsed ? pilotForceInput.y : 0f;
forceInput.z = longitudinalThrustInputUsed ? pilotForceInput.z : 0f;
momentInput.x = pitchMomentInputUsed ? pilotMomentInput.x : 0f;
momentInput.y = yawMomentInputUsed ? pilotMomentInput.y : 0f;
momentInput.z = rollMomentInputUsed ? pilotMomentInput.z : 0f;
pilotForceInput = forceInput;
pilotMomentInput = momentInput;
// Reset force and moment input
forceInput = Vector3.zero;
momentInput = Vector3.zero;
// Reset arcade force and moment vectors
arcadeForceVector = Vector3.zero;
arcadeMomentVector = Vector3.zero;
// Get the ship physics model
shipPhysicsModelPhysicsBased = shipPhysicsModel == ShipPhysicsModel.PhysicsBased;
// Get the ship damage model
shipDamageModelIsSimple = shipDamageModel == ShipDamageModel.Simple;
#endregion
#if SSC_SHIP_DEBUG
float initEndTime = Time.realtimeSinceStartup;
float groundStartTime = Time.realtimeSinceStartup;
#endif
#region Get Ground Information
if (limitPitchAndRoll)
{
if (stickToGroundSurface || avoidGroundSurface)
{
// TODO: This shouldn't always be centre of the object
//raycastRay.origin = trfmPos + (trfmFwd * 3.5f);
raycastRay.origin = trfmPos;
// If we were on the ground last frame, raycast in the "down" direction indicated by the ground normal
if (stickToGroundSurfaceEnabled) { raycastRay.direction = -worldTargetPlaneNormal; }
// Otherwise raycast in the ship's down direction
else { raycastRay.direction = -trfmUp; }
// Perform the raycast
if (Physics.Raycast(raycastRay, out raycastHitInfo, maxGroundCheckDistance, groundLayerMask, QueryTriggerInteraction.Ignore))
{
// Single normal, derived from raycast hit normal
// This is the backup for smoothed normals and average height methods
worldTargetPlaneNormal = raycastHitInfo.normal;
if (groundNormalCalculationMode == GroundNormalCalculationMode.SmoothedNormal)
{
// Only use smoothed normals if the ground is using a mesh collider
// Check for a valid number of triangles, as sometimes can return -1. This potentially happens when
// Unity simplifies the collider (called degenerate) to improve performance.
if (raycastHitInfo.collider != null && raycastHitInfo.collider.GetType() == typeof(MeshCollider) && raycastHitInfo.triangleIndex >= 0)
{
// Get the collider as a mesh collider
groundMeshCollider = (MeshCollider)raycastHitInfo.collider;
if (groundMeshCollider != null)
{
// Check if this mesh collider is the cached one - if it is, we can use
// the previously stored data without having to look it up from the mesh
if (groundMeshCollider != cachedGroundMeshCollider)
{
// If this mesh collider is not the cached one, cache the mesh data for next time
cachedGroundMeshCollider = groundMeshCollider;
// Get the shared mesh being used by the ground collider and check that it isn't null
cachedGroundMesh = groundMeshCollider.sharedMesh;
if (cachedGroundMesh != null)
{
// Get the normals and triangle indices arrays
cachedGroundMeshNormals = cachedGroundMesh.normals;
cachedGroundMeshTriangles = cachedGroundMesh.triangles;
}
}
// Get the normals from the triangle we hit using the cached data
groundNormal0 = cachedGroundMeshNormals[cachedGroundMeshTriangles[raycastHitInfo.triangleIndex * 3 + 0]];
groundNormal1 = cachedGroundMeshNormals[cachedGroundMeshTriangles[raycastHitInfo.triangleIndex * 3 + 1]];
groundNormal2 = cachedGroundMeshNormals[cachedGroundMeshTriangles[raycastHitInfo.triangleIndex * 3 + 2]];
// Get the barycentric coordinate of the point we hit - this gives us information as to
// where in the triangle this point is
barycentricCoord = raycastHitInfo.barycentricCoordinate;
// Interpolate between the three normals using the barycentric coordinate to
// get the smoothed normal - this is how smooth shading works
worldTargetPlaneNormal = groundMeshCollider.transform.TransformDirection(
barycentricCoord[0] * groundNormal0 +
barycentricCoord[1] * groundNormal1 +
barycentricCoord[2] * groundNormal2).normalized;
}
}
}
//else if (groundNormalCalculationMode == GroundNormalCalculationMode.AverageHeight)
//{
// float halfRectangleWidth = 3.5f;
// float halfRectangleLength = 5.5f;
// bool raycastFRHit, raycastFLHit, raycastRRHit, raycastRLHit;
// float nUsableNormals = 0f;
// Vector3 raycastFRHitPoint = Vector3.zero;
// Vector3 raycastFLHitPoint = Vector3.zero;
// Vector3 raycastRRHitPoint = Vector3.zero;
// Vector3 raycastRLHitPoint = Vector3.zero;
// RaycastHit testRaycastHitInfo;
// Ray testRaycastRay = new Ray();
// Vector3 averageNormal = Vector3.zero;
// // Front-right raycast
// testRaycastRay.origin = trfmPos + (trfmRight * halfRectangleWidth) + (trfmFwd * halfRectangleLength);
// testRaycastRay.direction = -trfmUp;
// if (Physics.Raycast(testRaycastRay, out testRaycastHitInfo, maxGroundCheckDistance, groundLayerMask, QueryTriggerInteraction.Ignore))
// {
// raycastFRHit = true;
// raycastFRHitPoint = testRaycastHitInfo.point;
// }
// else { raycastFRHit = false; }
// // Front-left raycast
// testRaycastRay.origin = trfmPos - (trfmRight * halfRectangleWidth) + (trfmFwd * halfRectangleLength);
// testRaycastRay.direction = -trfmUp;
// if (Physics.Raycast(testRaycastRay, out testRaycastHitInfo, maxGroundCheckDistance, groundLayerMask, QueryTriggerInteraction.Ignore))
// {
// raycastFLHit = true;
// raycastFLHitPoint = testRaycastHitInfo.point;
// }
// else { raycastFLHit = false; }
// // Rear-right raycast
// testRaycastRay.origin = trfmPos + (trfmRight * halfRectangleWidth) - (trfmFwd * halfRectangleLength);
// testRaycastRay.direction = -trfmUp;
// if (Physics.Raycast(testRaycastRay, out testRaycastHitInfo, maxGroundCheckDistance, groundLayerMask, QueryTriggerInteraction.Ignore))
// {
// raycastRRHit = true;
// raycastRRHitPoint = testRaycastHitInfo.point;
// }
// else { raycastRRHit = false; }
// // Rear-left raycast
// testRaycastRay.origin = trfmPos - (trfmRight * halfRectangleWidth) - (trfmFwd * halfRectangleLength);
// testRaycastRay.direction = -trfmUp;
// if (Physics.Raycast(testRaycastRay, out testRaycastHitInfo, maxGroundCheckDistance, groundLayerMask, QueryTriggerInteraction.Ignore))
// {
// raycastRLHit = true;
// raycastRLHitPoint = testRaycastHitInfo.point;
// }
// else { raycastRLHit = false; }
// if (raycastFLHit && raycastFRHit && raycastRRHit)
// {
// nUsableNormals += 1f;
// averageNormal += Vector3.Cross(raycastRRHitPoint - raycastFRHitPoint, raycastFLHitPoint - raycastFRHitPoint).normalized;
// }
// if (raycastFRHit && raycastRRHit && raycastRLHit)
// {
// nUsableNormals += 1f;
// averageNormal += Vector3.Cross(raycastRLHitPoint - raycastRRHitPoint, raycastFRHitPoint - raycastRRHitPoint).normalized;
// }
// if (raycastRRHit && raycastRLHit && raycastFLHit)
// {
// nUsableNormals += 1f;
// averageNormal += Vector3.Cross(raycastFLHitPoint - raycastRLHitPoint, raycastRRHitPoint - raycastRLHitPoint).normalized;
// }
// if (raycastRLHit && raycastFLHit && raycastFRHit)
// {
// nUsableNormals += 1f;
// averageNormal += Vector3.Cross(raycastFRHitPoint - raycastFLHitPoint, raycastRLHitPoint - raycastFLHitPoint).normalized;
// }
// if (nUsableNormals > 0f) { worldTargetPlaneNormal = (averageNormal / nUsableNormals).normalized; }
//}
// Calculate a normal averaged from the last few frames
UpdateGroundNormalHistory(worldTargetPlaneNormal);
worldTargetPlaneNormal = GetDampedGroundNormal();
// Get target plane normal in local space
localTargetPlaneNormal = trfmInvRot * worldTargetPlaneNormal;
// Calculate distance to the ground in a direction parallel to the ground normal
// (from the ground directly beneath the ship)
currentPerpendicularGroundDist = Vector3.Dot(trfmPos - raycastHitInfo.point, worldTargetPlaneNormal);
//Debug.DrawRay(raycastRay.origin, raycastRay.direction.normalized * maxGroundCheckDistance, Color.blue);
// If required, use look ahead to check if there is an obstacle ahead we will need to go over
if (useGroundMatchLookAhead)
{
float maxRaycastDistance;
RaycastHit secondaryRaycastHitInfo;
// Loop through a series of different look ahead times, starting at half a second away
for (float groundMatchLookAheadTime = 0.5f; groundMatchLookAheadTime > 0.01f; groundMatchLookAheadTime -= 0.1f)
{
// Calculate the corresponding look ahead distance
float groundMatchLookAheadDistance = groundMatchLookAheadTime * localVelocity.z;
// Calculate the raycast direction
raycastRay.direction = (-currentPerpendicularGroundDist * worldTargetPlaneNormal) + (groundMatchLookAheadDistance * trfmFwd);
// Calculate the required raycast length to go down the same distance as the standard ground check
maxRaycastDistance = Mathf.Sqrt((currentPerpendicularGroundDist * currentPerpendicularGroundDist) +
(groundMatchLookAheadDistance * groundMatchLookAheadDistance)) * (maxGroundCheckDistance / currentPerpendicularGroundDist);
// Perform the raycast
if (Physics.Raycast(raycastRay, out secondaryRaycastHitInfo, maxRaycastDistance, groundLayerMask,
QueryTriggerInteraction.Ignore))
{
// Calculate the perpendicular ground distance (projected onto the target normal)
float futurePerpendicularGroundDistance = Vector3.Dot(trfmPos - secondaryRaycastHitInfo.point, worldTargetPlaneNormal);
// If the perpendicular ground distance we have calculated is LESS than the current
// perpendicular ground distance (i.e. for the ground beneath the ship), use this
// new ground distance instead
if (futurePerpendicularGroundDistance <= currentPerpendicularGroundDist)
{
currentPerpendicularGroundDist = futurePerpendicularGroundDistance;
//Debug.DrawRay(raycastRay.origin, raycastRay.direction.normalized * maxRaycastDistance, Color.green);
// Exit the loop
break;
}
//else
//{
// Debug.DrawRay(raycastRay.origin, raycastRay.direction.normalized * maxRaycastDistance, Color.red);
//}
}
}
}
// Set relevant variables, to indicate to later code that we have found a ground surface
limitPitchAndRollEnabled = true;
stickToGroundSurfaceEnabled = true;
}
else
{
// If we were on the ground on the previous frame, and now we are not,
// reset the PID controller to prevent spikes when we go back onto the ground again
if (stickToGroundSurfaceEnabled) { groundDistPIDController.ResetController(); }
limitPitchAndRollEnabled = orientUpInAir;
stickToGroundSurfaceEnabled = false;
if (limitPitchAndRollEnabled)
{
worldTargetPlaneNormal = Vector3.up;
// Update ground normal history
UpdateGroundNormalHistory(worldTargetPlaneNormal);
// Get target plane normal in local space
localTargetPlaneNormal = trfmInvRot * worldTargetPlaneNormal;
}
else
{
// Update ground normal history
UpdateGroundNormalHistory(trfmUp);
}
}
}
else
{
limitPitchAndRollEnabled = true;
stickToGroundSurfaceEnabled = false;
worldTargetPlaneNormal = Vector3.up;
// Get target plane normal in local space
localTargetPlaneNormal = trfmInvRot * worldTargetPlaneNormal;
}
}
else
{
limitPitchAndRollEnabled = false;
stickToGroundSurfaceEnabled = false;
}
#endregion
#if SSC_SHIP_DEBUG
float groundEndTime = Time.realtimeSinceStartup;
#endif
#region Gravity
// Calculate acceleration due to gravity in local space (storing the value for use later)
localGravityAcceleration = trfmInvRot * gravityDirection * gravitationalAcceleration;
// Then add it to local resultant force vector (multiplying by mass to turn it into a force)
localResultantForce += localGravityAcceleration * mass;
#endregion
#if SSC_SHIP_DEBUG
float inputStartTime = Time.realtimeSinceStartup;
#endif
#region Calculate Final Inputs
// Calculate final input
// | Assists/limiters info |
// Rotational flight assist:
// - Always on
// - If the pilot has released an axial input but we are still spinning on that axis,
// modify the input to slow down the spin
// Translational flight assist:
// - Always on
// - If the pilot has released a translational input but we are still moving on that axis,
// modify the input to slow down the movement
// - Is overriden on y-axis by stick to ground surface
// - Currently does not apply on z-axis
// - Isn't available in arcade mode (it is instead replaced by velocity match code)
// Brake flight assist:
// - Off by default
// - Translational flight assist on z-axis only
// - Only applies when no z-axis input
// - Only applies when fwd/back movement is non-zero and not close to zero
// - Can be overridden in forwards direction by AutoCruise on PlayerInputModule
// Limit pitch and roll:
// - Overrides x and z axes of rotational flight assist
// - Causes y-axis rotational flight assist to apply on an axis normal to the target plane
// Stick to ground surface
// - Overrides y axis of pilot force input
// Moment inputs
// - Rotational flight assist
if (limitPitchAndRollEnabled)
{
// Ground angle match assist: Calculate a target pitch and roll from the ground angle
// Pitch is still affected by pilot input but is clamped between min and max pitch
// Roll is controlled by yaw input or strafe input
// Calculate target plane normal in local space
// Calculate target pitch (relative to the ground normal) in degrees
// This is always dependent on the pitch input
pitchAmountInput = pilotMomentInput.x * maxPitch;
// Calculate target roll (relative to the ground normal) in degrees
// a) From the yaw input
if (rollControlMode == RollControlMode.YawInput) { rollAmountInput = pilotMomentInput.y * maxTurnRoll; }
// b) From the strafe input
else { rollAmountInput = pilotForceInput.x * maxTurnRoll; }
// Calculate the maximum possible change in pitch/roll for this frame
maxFramePitchDelta = _deltaTime * pitchSpeed;
maxFrameRollDelta = _deltaTime * turnRollSpeed;
// Move the pitch amount towards the target pitch input
if (pitchAmountInput >= pitchAmount - maxFramePitchDelta && pitchAmountInput <= pitchAmount + maxFramePitchDelta) { pitchAmount = pitchAmountInput; }
else if (pitchAmountInput > pitchAmount) { pitchAmount += maxFramePitchDelta; }
else { pitchAmount -= maxFramePitchDelta; }
// Move the roll amount towards the target roll input
if (rollAmountInput >= rollAmount - maxFrameRollDelta && rollAmountInput <= rollAmount + maxFrameRollDelta) { rollAmount = rollAmountInput; }
else if (rollAmountInput > rollAmount) { rollAmount += maxFrameRollDelta; }
else { rollAmount -= maxFrameRollDelta; }
// Calculate target local-space roll and pitch in degrees
targetLocalPitch = ((float)Math.Atan2(localTargetPlaneNormal.z, localTargetPlaneNormal.y) * Mathf.Rad2Deg) + pitchAmount;
targetLocalRoll = ((float)Math.Atan2(localTargetPlaneNormal.x, localTargetPlaneNormal.y) * Mathf.Rad2Deg) + rollAmount;
//Debug.Log("Target pitch: " + targetLocalPitch.ToString("00.00") + ", target roll: " + targetLocalRoll.ToString("00.00"));
if (shipPhysicsModelPhysicsBased)
{
// Use the PID controllers to calculate the required moment inputs on the x and z axes
momentInput.z = rollPIDController.RequiredInput(targetLocalRoll, 0f, _deltaTime);
momentInput.x = pitchPIDController.RequiredInput(targetLocalPitch, 0f, _deltaTime);
momentInput.y = 0f;
}
else
{
// Use the PID controllers to calculate the required moments on the x and z axes
arcadeMomentVector.z = rollPIDController.RequiredInput(targetLocalRoll, 0f, _deltaTime) * 50f * pitchRollMatchResponsiveness;
arcadeMomentVector.x = pitchPIDController.RequiredInput(targetLocalPitch, 0f, _deltaTime) * 50f * pitchRollMatchResponsiveness;
arcadeMomentVector.y = 0f;
// Completely reset moment input here
momentInput = Vector3.zero;
}
// Apply typical yaw rotation with respect to ground normal instead of local y coordinate
// TODO: Surely this line can be optimised...?
yawVelocity = Vector3.Dot(Vector3.Project(localAngularVelocity * Mathf.Rad2Deg, localTargetPlaneNormal), localTargetPlaneNormal);
if (shipPhysicsModelPhysicsBased)
{
// Activate rotational flight assist if pilot releases an input
// or if input is in direction opposing rotational velocity
if ((pilotMomentInput.y > 0f) == (yawVelocity < 0f) || pilotMomentInput.y == 0f)
{
// Calculate the flight assist value on the ground normal axis
flightAssistValue = -yawVelocity / 100f * rotationalFlightAssistStrength;
// Choose whichever value has the highest absolute value: The flight assist value or the pilot input value
if ((flightAssistValue > 0f ? flightAssistValue : -flightAssistValue) >
(pilotMomentInput.y > 0f ? pilotMomentInput.y : -pilotMomentInput.y))
{
momentInput += localTargetPlaneNormal * flightAssistValue;
}
else { momentInput += localTargetPlaneNormal * pilotMomentInput.y; }
}
else { momentInput += localTargetPlaneNormal * pilotMomentInput.y; }
}
else
{
momentInput += localTargetPlaneNormal * pilotMomentInput.y;
// Activate arcade rotational flight assist if pilot releases an input
// or if input is in direction opposing rotational velocity
if ((pilotMomentInput.y > 0f) == (yawVelocity < 0f) || pilotMomentInput.y == 0f)
{
// Calculate the flight assist value on the ground normal axis
arcadeMomentVector += localTargetPlaneNormal * -yawVelocity * rotationalFlightAssistStrength;
}
}
}
else
{
// Rotational flight assist: Input to counteract rotational velocity
if (shipPhysicsModelPhysicsBased)
{
// Activate rotational flight assist if pilot releases an input
// or if input is in direction opposing rotational velocity
if ((pilotMomentInput.x > 0f) == (localAngularVelocity.x < 0f) || pilotMomentInput.x == 0f)
{
// Calculate the flight assist value on this axis
flightAssistValue = -localAngularVelocity.x * Mathf.Rad2Deg / 100f * rotationalFlightAssistStrength;
// Choose whichever value has the highest absolute value: The flight assist value or the pilot input value
if ((flightAssistValue > 0f ? flightAssistValue : -flightAssistValue) >
(pilotMomentInput.x > 0f ? pilotMomentInput.x : -pilotMomentInput.x)) { momentInput.x = flightAssistValue; }
else { momentInput.x = pilotMomentInput.x; }
}
else { momentInput.x = pilotMomentInput.x; }
if ((pilotMomentInput.y > 0f) == (localAngularVelocity.y < 0f) || pilotMomentInput.y == 0f)
{
// Calculate the flight assist value on this axis
flightAssistValue = -localAngularVelocity.y * Mathf.Rad2Deg / 100f * rotationalFlightAssistStrength;
// Choose whichever value has the highest absolute value: The flight assist value or the pilot input value
if ((flightAssistValue > 0f ? flightAssistValue : -flightAssistValue) >
(pilotMomentInput.y > 0f ? pilotMomentInput.y : -pilotMomentInput.y)) { momentInput.y = flightAssistValue; }
else { momentInput.y = pilotMomentInput.y; }
}
else { momentInput.y = pilotMomentInput.y; }
if ((pilotMomentInput.z > 0f) == (localAngularVelocity.z > 0f) || pilotMomentInput.z == 0f)
{
// Calculate the flight assist value on this axis
flightAssistValue = localAngularVelocity.z * Mathf.Rad2Deg / 100f * rotationalFlightAssistStrength;
// Choose whichever value has the highest absolute value: The flight assist value or the pilot input value
if ((flightAssistValue > 0f ? flightAssistValue : -flightAssistValue) >
(pilotMomentInput.z > 0f ? pilotMomentInput.z : -pilotMomentInput.z)) { momentInput.z = flightAssistValue; }
else { momentInput.z = pilotMomentInput.z; }
}
else { momentInput.z = pilotMomentInput.z; }
}
else
{
// Activate arcade rotational flight assist if pilot releases an input
// or if input is in direction opposing rotational velocity
momentInput = pilotMomentInput;
if ((pilotMomentInput.x > 0f) == (localAngularVelocity.x < 0f) || pilotMomentInput.x == 0f)
{
arcadeMomentVector.x = -localAngularVelocity.x * Mathf.Rad2Deg * rotationalFlightAssistStrength;
}
if ((pilotMomentInput.y > 0f) == (localAngularVelocity.y < 0f) || pilotMomentInput.y == 0f)
{
arcadeMomentVector.y = -localAngularVelocity.y * Mathf.Rad2Deg * rotationalFlightAssistStrength;
}
if ((pilotMomentInput.z > 0f) == (localAngularVelocity.z > 0f) || pilotMomentInput.z == 0f)
{
arcadeMomentVector.z = localAngularVelocity.z * Mathf.Rad2Deg * rotationalFlightAssistStrength;
}
}
}
if (stabilityFlightAssistStrength > 0f)
{
// TODO I need to optimise the calculation section
#region Calculate Current Pitch, Yaw and Roll
// TODO I really need to optimise this properly
// Calculate current pitch of the ship
Vector3 pitchProjectionPlaneNormal = Vector3.Cross(Vector3.up, TransformForward);
Vector3 pitchProjectedUpDirection = Vector3.ProjectOnPlane(TransformUp, pitchProjectionPlaneNormal);
float stabilityCurrentPitch = Vector3.SignedAngle(Vector3.up, pitchProjectedUpDirection, pitchProjectionPlaneNormal);
// Measure pitch with respect to target pitch direction
stabilityCurrentPitch -= sFlightAssistTargetPitch;
if (stabilityCurrentPitch > 180f) { stabilityCurrentPitch -= 360f; }
else if (stabilityCurrentPitch < -180f) { stabilityCurrentPitch += 360f; }
// Calculate current yaw of the ship
// TODO this can be massively optimised by just setting the y-value to zero
Vector3 yawProjectionPlaneNormal = Vector3.up;
Vector3 yawProjectedForwardDirection = Vector3.ProjectOnPlane(TransformForward, yawProjectionPlaneNormal);
float stabilityCurrentYaw = Vector3.SignedAngle(Vector3.forward, yawProjectedForwardDirection, yawProjectionPlaneNormal);
// Measure yaw with respect to target yaw direction
stabilityCurrentYaw -= sFlightAssistTargetYaw;
if (stabilityCurrentYaw > 180f) { stabilityCurrentYaw -= 360f; }
else if (stabilityCurrentYaw < -180f) { stabilityCurrentYaw += 360f; }
// Calculate current roll of the ship
Vector3 rollProjectionPlaneNormal = TransformForward;
rollProjectionPlaneNormal.y = 0f;
Vector3 rollProjectedUpDirection = Vector3.ProjectOnPlane(TransformUp, rollProjectionPlaneNormal);
float stabilityCurrentRoll = -Vector3.SignedAngle(Vector3.up, rollProjectedUpDirection, rollProjectionPlaneNormal);
// Measure roll with respect to target roll direction
stabilityCurrentRoll -= sFlightAssistTargetRoll;
if (stabilityCurrentRoll > 180f) { stabilityCurrentRoll -= 360f; }
else if (stabilityCurrentRoll < -180f) { stabilityCurrentRoll += 360f; }
#endregion
#region Update Target Pitch, Yaw and Roll Values
// How this works: There are two (mutually exclusive) modes of operation:
// 1. Setting target values for pitch/yaw/roll
// 2. Applying the stability assist for pitch/yaw/roll
// For example, if the target pitch is being set, this means that the stability assist will not be used
// for pitch in that frame
bool allowPitchStabilityAssist = true;
bool allowYawStabilityAssist = true;
bool allowRollStabilityAssist = true;
// Check if the pilot is initiating a manoeuvre on any of the three axes via pilot input
bool initiatingPitchManoeuvre = pilotMomentInput.x > 0.01f || pilotMomentInput.x < -0.01f;
bool initiatingYawManoeuvre = pilotMomentInput.y > 0.01f || pilotMomentInput.y < -0.01f;
bool initiatingRollManoeuvre = pilotMomentInput.z > 0.01f || pilotMomentInput.z < -0.01f;
// If there is currently some pilot pitch/yaw/roll input...
if (initiatingPitchManoeuvre || initiatingRollManoeuvre || initiatingYawManoeuvre)
{
// ... set the target pitch/yaw/roll
sFlightAssistTargetPitch += stabilityCurrentPitch;
sFlightAssistPitchPIDController.ResetController();
sFlightAssistTargetYaw += stabilityCurrentYaw;
sFlightAssistYawPIDController.ResetController();
sFlightAssistTargetRoll += stabilityCurrentRoll;
sFlightAssistRollPIDController.ResetController();
allowPitchStabilityAssist = false;
allowYawStabilityAssist = false;
allowRollStabilityAssist = false;
// If a manouevre has been initiated on a given axis via pilot input, remember it
// We can hence know when we are rotating on a particular axis due to pilot input
// or due to drag moments etc and act accordingly
// Note that pitch can affect yaw and vice versa
if (initiatingPitchManoeuvre || initiatingYawManoeuvre)
{
sFlightAssistRotatingPitch = true;
sFlightAssistRotatingYaw = true;
}
if (initiatingRollManoeuvre) { sFlightAssistRotatingRoll = true; }
}
// Otherwise...
else
{
// If there is a significant pitch assist input to correct a pitch manoeuvre...
if (sFlightAssistRotatingPitch && (momentInput.x > 0.3f || momentInput.x < -0.3f))
{
// ... set the target pitch
sFlightAssistTargetPitch += stabilityCurrentPitch;
sFlightAssistPitchPIDController.ResetController();
allowPitchStabilityAssist = false;
}
// When the pitch assist moment input has reduced enough, we can assume we have finished
// any pitch manoeuvres initiated by the pilot
else { sFlightAssistRotatingPitch = false; }
// If there is a significant yaw assist input to correct a yaw manoeuvre...
if (sFlightAssistRotatingYaw && (momentInput.y > 0.3f || momentInput.y < -0.3f))
{
// ... set the target yaw
sFlightAssistTargetYaw += stabilityCurrentYaw;
sFlightAssistYawPIDController.ResetController();
allowYawStabilityAssist = false;
}
// When the yaw assist moment input has reduced enough, we can assume we have finished
// any yaw manoeuvres initiated by the pilot
else { sFlightAssistRotatingYaw = false; }
// If there is a significant roll assist input to correct a roll manoeuvre...
if (sFlightAssistRotatingRoll && (momentInput.z > 0.3f || momentInput.z < -0.3f))
{
// ... set the target roll
sFlightAssistTargetRoll += stabilityCurrentRoll;
sFlightAssistRollPIDController.ResetController();
allowRollStabilityAssist = false;
}
// When the roll assist moment input has reduced enough, we can assume we have finished
// any roll manoeuvres initiated by the pilot
else { sFlightAssistRotatingRoll = false; }
}
#endregion
#region Apply Stability Assist
if (allowPitchStabilityAssist)
{
// Get input from pitch PID controller and apply it
momentInput.x += sFlightAssistPitchPIDController.RequiredInput(0f, stabilityCurrentPitch, _deltaTime);
}
if (allowYawStabilityAssist)
{
// Get input from yaw PID controller and apply it
momentInput.y += sFlightAssistYawPIDController.RequiredInput(0f, stabilityCurrentYaw, _deltaTime);
}
if (allowRollStabilityAssist)
{
// Get input from roll PID controller and apply it
momentInput.z += sFlightAssistRollPIDController.RequiredInput(0f, stabilityCurrentRoll, _deltaTime);
}
#endregion
}
if (shipPhysicsModelPhysicsBased)
{
// Scale moment inputs in physics-based mode - they generally need to be a lot less than force inputs
momentInput.x *= pitchPower;
momentInput.y *= yawPower;
momentInput.z *= rollPower;
// Clamp moment inputs to be between -1 and 1. We don't do this in arcade mode so that moment assists/limits
// can use more than the specified maximum moments if necessary
if (momentInput.x > 1f) { momentInput.x = 1f; }
else if (momentInput.x < -1f) { momentInput.x = -1f; }
if (momentInput.y > 1f) { momentInput.y = 1f; }
else if (momentInput.y < -1f) { momentInput.y = -1f; }
if (momentInput.z > 1f) { momentInput.z = 1f; }
else if (momentInput.z < -1f) { momentInput.z = -1f; }
}
// Force inputs
// - Translational flight assist (physics-based only)
// - Stick to ground surface (physics-based only: arcade equivalent is applied separately)
if (shipPhysicsModelPhysicsBased)
{
// Translational flight assist: Input to counteract translational velocity
// Activate translational flight assist if pilot releases an input
// or if input is in direction opposing velocity
if ((pilotForceInput.x > 0f) == (localVelocity.x < 0f) || pilotForceInput.x == 0f)
{
// Calculate the flight assist value on this axis
flightAssistValue = -localVelocity.x / 100f * translationalFlightAssistStrength;
if (flightAssistValue > 1f) { flightAssistValue = 1f; }
else if (flightAssistValue < -1f) { flightAssistValue = -1f; }
// Choose whichever value has the highest absolute value: The flight assist value or the pilot input value
if ((flightAssistValue > 0f ? flightAssistValue : -flightAssistValue) >
(pilotForceInput.x > 0f ? pilotForceInput.x : -pilotForceInput.x)) { forceInput.x = flightAssistValue; }
else { forceInput.x = pilotForceInput.x; }
}
else { forceInput.x = pilotForceInput.x; }
if (stickToGroundSurfaceEnabled)
{
// Get input from ground distance PID controller
forceInput.y = groundDistPIDController.RequiredInput(targetGroundDistance, currentPerpendicularGroundDist, _deltaTime);
// NOTE: This hasn't been tested yet in physics-model mode
if (avoidGroundSurface)
{
// Only override user input if the ship is going below the targetGroundDistance
forceInput.y = forceInput.y > 0f ? forceInput.y : pilotForceInput.y;
}
}
else
{
// Activate translational flight assist if pilot releases an input
// or if input is in direction opposing velocity
if ((pilotForceInput.y > 0f) == (localVelocity.y < 0f) || pilotForceInput.y == 0f)
{
// Calculate the flight assist value on this axis
flightAssistValue = -localVelocity.y / 100f * translationalFlightAssistStrength;
if (flightAssistValue > 1f) { flightAssistValue = 1f; }
else if (flightAssistValue < -1f) { flightAssistValue = -1f; }
// Choose whichever value has the highest absolute value: The flight assist value or the pilot input value
if ((flightAssistValue > 0f ? flightAssistValue : -flightAssistValue) >
(pilotForceInput.y > 0f ? pilotForceInput.y : -pilotForceInput.y)) { forceInput.y = flightAssistValue; }
else { forceInput.y = pilotForceInput.y; }
}
else { forceInput.y = pilotForceInput.y; }
}
// Force input on z-axis is always just pilot input
forceInput.z = pilotForceInput.z;
}
else
{
forceInput.x = pilotForceInput.x;
// In arcade mode, stick-to-ground force isn't achieved through thrusters
// Currently this implementation won't allow for thrust pushing up/down from ground
// to activate particle trails in non-physics-based mode...
forceInput.y = stickToGroundSurfaceEnabled ? 0f : pilotForceInput.y;
forceInput.z = pilotForceInput.z;
}
#region Brake flight assist
// Pilot or AI releases input and ship is moving forwards or backwards
// Works within the speed range configured.
// Does not make adjustments if velocity is very near zero.
if (brakeFlightAssistStrength > 0f && forceInput.z == 0f && localVelocity.z > brakeFlightAssistMinSpeed && localVelocity.z < brakeFlightAssistMaxSpeed && (localVelocity.z < -0.01f || localVelocity.z > 0.01f))
{
// Max brakeFlightAssistStrength is 10, so div by 10 (x 0.1)
// Apply thrust in the opposite direction to current z-axis velocity
flightAssistValue = (localVelocity.z < 0f ? brakeFlightAssistStrength : -brakeFlightAssistStrength) * 0.1f;
// Dampen based on how close velo is to 0 using a x^2 curve when velo between -10 and +10 m/s.
if (localVelocity.z > 0f && localVelocity.z < 10f) { flightAssistValue *= localVelocity.z / 10f; }
else if (localVelocity.z < 0f && localVelocity.z > -10f) { flightAssistValue *= localVelocity.z / -10f; }
// Clamp -1.0 to 1.0
if (flightAssistValue > 1f) { flightAssistValue = 1f; }
else if (flightAssistValue < -1f) { flightAssistValue = -1f; }
forceInput.z = flightAssistValue;
}
#endregion
#region Input Control - 2.5D
// TODO probably can significantly optimise the input control axis code
if ((int)inputControlAxis > 0)
{
// Y axis for side-view OR top-down flight
if ((int)inputControlAxis == 2)
{
// Project the transform right direction onto the XZ plane
Vector3 flatTrfmRight = TransformRight;
flatTrfmRight.y = 0f;
// Project the transform forward direction onto the XZ plane...
Vector3 targetForward = TransformForward;
targetForward.y = 0f;
// ... then onto the plane of the ship's up and forwards directions while keeping it on the XZ plane
// To do this step we subtract the projection of this vector onto flatTrfmRight
targetForward -= (Vector3.Dot(targetForward, flatTrfmRight) / Vector3.Dot(flatTrfmRight, flatTrfmRight)) * flatTrfmRight;
// Measure the angle from this projected forwards direction (which will be the target) to the current forwards direction
float inputControlLimitAngleDelta = Vector3.SignedAngle(targetForward, TransformForward, TransformRight);
if (shipPhysicsModelPhysicsBased)
{
// Physics-based: Set the inputs to counteract any displacement from the target position/rotation
forceInput.y = inputAxisForcePIDController.RequiredInput(inputControlLimit, TransformPosition.y, _deltaTime);
momentInput.x = inputAxisMomentPIDController.RequiredInput(0f, inputControlLimitAngleDelta, _deltaTime);
}
else
{
// Arcade: Use arcade force/moment to counteract any displacement from the target position/rotation
arcadeForceVector.y += inputAxisForcePIDController.RequiredInput(inputControlLimit, TransformPosition.y, _deltaTime);
arcadeMomentVector.x += inputAxisMomentPIDController.RequiredInput(0f, inputControlLimitAngleDelta, _deltaTime);
// Set inputs to zero
forceInput.y = 0f;
momentInput.x = 0f;
}
}
// X axis for side-scroller-like flight
else if ((int)inputControlAxis == 1)
{
// Calculate the normal to the plane we want to remain in
Vector3 targetInputControlPlaneNormal = Quaternion.Euler(0f, inputControlForwardAngle, 0f) * Vector3.right;
// Project the transform up direction onto the YZ plane
Vector3 flatTrfmUp = TransformUp;
flatTrfmUp -= Vector3.Project(flatTrfmUp, targetInputControlPlaneNormal);
// Project the transform forward direction onto the YZ plane...
Vector3 targetForward = TransformForward;
targetForward -= Vector3.Project(targetForward, targetInputControlPlaneNormal);
// ... then onto the plane of the ship's right and forwards directions while keeping it on the YZ plane
// To do this step we subtract the projection of this vector onto flatTrfmUp
targetForward -= (Vector3.Dot(targetForward, flatTrfmUp) / Vector3.Dot(flatTrfmUp, flatTrfmUp)) * flatTrfmUp;
// Measure the angle from this projected forwards direction (which will be the target) to the current forwards direction
float inputControlLimitAngleDelta = Vector3.SignedAngle(targetForward, TransformForward, TransformUp);
if (shipPhysicsModelPhysicsBased)
{
// Physics-based: Set the inputs to counteract any displacement from the target position/rotation
forceInput.x = inputAxisForcePIDController.RequiredInput(inputControlLimit, TransformPosition.x, _deltaTime);
momentInput.y = inputAxisMomentPIDController.RequiredInput(0f, inputControlLimitAngleDelta, _deltaTime);
}
else
{
// Arcade: Use arcade force/moment to counteract any displacement from the target position/rotation
arcadeForceVector.x += inputAxisForcePIDController.RequiredInput(inputControlLimit, TransformPosition.x, _deltaTime);
arcadeMomentVector.y += inputAxisMomentPIDController.RequiredInput(0f, inputControlLimitAngleDelta, _deltaTime);
// Set inputs to zero
forceInput.x = 0f;
momentInput.y = 0f;
}
}
}
#endregion
#endregion
#if SSC_SHIP_DEBUG
float inputEndTime = Time.realtimeSinceStartup;
float thrusterStartTime = Time.realtimeSinceStartup;
#endif
#region Thrusters
if (thrusterList != null)
{
componentListSize = thrusterList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
// Get the thruster we are concerned with
thruster = thrusterList[componentIndex];
// Calculate thruster input - for this we need to know what type of thruster
// this is so that we can read the right input/s
// First set thruster input to zero
thruster.currentInput = 0f;
// Thrusters with max heat (temperature) or with no fuel produce no thrust etc.
// Check heat before fuels, so that if we run out of fuel, thruster
// can still cool down.
if (thruster.heatLevel >= 100f || (useCentralFuel ? centralFuelLevel <= 0f : thruster.fuelLevel <= 0f))
{
// Check if we need to cool the thruster down
thruster.ManageHeat(_deltaTime);
continue;
}
// Then add inputs for force/moments to give a final input...
switch (thruster.forceUse)
{
// Not a force thruster
case 0: break;
// Forward thruster
case 1: thruster.currentInput += (forceInput.z > 0f ? forceInput.z : 0f); break;
// Backward thruster
case 2: thruster.currentInput += (forceInput.z < 0f ? -forceInput.z : 0f); break;
// Upward thruster
case 3: thruster.currentInput += (forceInput.y > 0f ? forceInput.y : 0f); break;
// Downward thruster
case 4: thruster.currentInput += (forceInput.y < 0f ? -forceInput.y : 0f); break;
// Rightward thruster
case 5: thruster.currentInput += (forceInput.x > 0f ? forceInput.x : 0f); break;
// Leftward thruster
case 6: thruster.currentInput += (forceInput.x < 0f ? -forceInput.x : 0f); break;
// Not a valid thruster type
#if UNITY_EDITOR
default: Debug.Log("Ship - Invalid thruster force use: " + thruster.forceUse.ToString()); break;
#endif
}
// Only allow thrusters to affect rotation when using the physics-based model
if (shipPhysicsModelPhysicsBased)
{
// Addition of moment inputs can be negative i.e. if we need to rotate in the opposite direction, add weighting
// to tell this thruster not to activate
switch (thruster.primaryMomentUse)
{
// Not a moment thruster
case 0: break;
// Positive roll thruster
case 1: if (momentInput.z / rollPower >= -(1f - (steeringThrusterPriorityLevel * 0.9f))) { thruster.currentInput += momentInput.z; } else { thruster.currentInput = 0f; } break;
// Negative roll thruster
case 2: if (momentInput.z / rollPower <= (1f - (steeringThrusterPriorityLevel * 0.9f))) { thruster.currentInput -= momentInput.z; } else { thruster.currentInput = 0f; } break;
// Positive pitch thruster
case 3: if (momentInput.x / pitchPower >= -(1f - (steeringThrusterPriorityLevel * 0.9f))) { thruster.currentInput += momentInput.x; } else { thruster.currentInput = 0f; } break;
// Negative pitch thruster
case 4: if (momentInput.x / pitchPower <= (1f - (steeringThrusterPriorityLevel * 0.9f))) { thruster.currentInput -= momentInput.x; } else { thruster.currentInput = 0f; } break;
// Positive yaw thruster
case 5: if (momentInput.y / yawPower >= -(1f - (steeringThrusterPriorityLevel * 0.9f))) { thruster.currentInput += momentInput.y; } else { thruster.currentInput = 0f; } break;
// Negative yaw thruster
case 6: if (momentInput.y / yawPower <= (1f - (steeringThrusterPriorityLevel * 0.9f))) { thruster.currentInput -= momentInput.y; } else { thruster.currentInput = 0f; } break;
// Not a valid thruster type
#if UNITY_EDITOR
default: Debug.Log("Ship - Invalid thruster moment use: " + thruster.primaryMomentUse.ToString()); break;
#endif
}
switch (thruster.secondaryMomentUse)
{
// Not a moment thruster
case 0: break;
// Positive roll thruster
case 1: thruster.currentInput += momentInput.z; break;
// Negative roll thruster
case 2: thruster.currentInput -= momentInput.z; break;
// Positive pitch thruster
case 3: thruster.currentInput += momentInput.x; break;
// Negative pitch thruster
case 4: thruster.currentInput -= momentInput.x; break;
// Positive yaw thruster
case 5: thruster.currentInput += momentInput.y; break;
// Negative yaw thruster
case 6: thruster.currentInput -= momentInput.y; break;
// Not a valid thruster type
#if UNITY_EDITOR
default: Debug.Log("Ship - Invalid thruster moment use: " + thruster.secondaryMomentUse.ToString()); break;
#endif
}
}
// Calculate thrust force
// Allow for the thruster to be throttled up and down over time
// Input is clamped between 0 and 1 (can only act within physical constraints of thruster)
thruster.SmoothThrusterInput(_deltaTime);
thrustForce = thruster.thrustDirectionNormalised * thruster.maxThrust * thruster.currentInput;
if (useCentralFuel)
{
if (thruster.fuelBurnRate > 0f && thruster.currentInput > 0f)
{
// Burn fuel independently to the health level. A damaged thruster will burn the same
// amount of fuel but produce less thrust
SetFuelLevel(centralFuelLevel - (thruster.currentInput * thruster.fuelBurnRate * _deltaTime));
}
}
else
{
thruster.BurnFuel(_deltaTime);
}
thruster.ManageHeat(_deltaTime);
// Adjust for thruster damage
if (!shipDamageModelIsSimple && thruster.damageRegionIndex > -1)
{
thrustForce *= thruster.CurrentPerformance;
}
// Add calculated thrust force to local resultant force and moment
localResultantForce += thrustForce;
// Only allow thrusters to affect rotation when using the physics-based model
if (shipPhysicsModelPhysicsBased)
{
localResultantMoment += Vector3.Cross(thruster.relativePosition - centreOfMass, thrustForce);
}
}
}
#endregion
#if SSC_SHIP_DEBUG
float thrusterEndTime = Time.realtimeSinceStartup;
float aeroStartTime = Time.realtimeSinceStartup;
#endif
#region Boost
// Is boost currently in operation?
if (boostTimer > 0f)
{
boostTimer -= _deltaTime;
localResultantForce += boostDirection * boostForce;
}
#endregion
#region Aerodynamics
// Dynamic viscosity of air at 25 deg C and 1 atm: 18.37 x 10^-6 Pa s
// Density of air on earth at low altitudes: 1.293 kg/m^3
// Aircraft head-on drag coefficient: ~0.05
if (mediumDensity > 0f)
{
//float pDragStartTime = Time.realtimeSinceStartup;
#region Profile Drag
// Profile drag calculation
// Calculate local drag force vector
// Drag force magnitude = 0.5 * fluid density * velocity squared * drag coefficient * cross-sectional area
localDragForce = 0.5f * mediumDensity * -localVelocity;
localDragForce.x *= dragCoefficients.x * dragReferenceAreas.x * (localVelocity.x > 0 ? localVelocity.x : -localVelocity.x);
localDragForce.y *= dragCoefficients.y * dragReferenceAreas.y * (localVelocity.y > 0 ? localVelocity.y : -localVelocity.y);
localDragForce.z *= dragCoefficients.z * dragReferenceAreas.z * (localVelocity.z > 0 ? localVelocity.z : -localVelocity.z);
// Add calculated drag force to local resultant force
localResultantForce += localDragForce;
if (!disableDragMoments)
{
// Add calculated drag force to local resultant moment
// Centre of drag is precalculated separately for each axis
localResultantMoment.x += ((centreOfDragXMoment.y - centreOfMass.y) * localDragForce.z) * dragXMomentMultiplier;
localResultantMoment.x += ((centreOfDragXMoment.z - centreOfMass.z) * -localDragForce.y) * dragXMomentMultiplier;
localResultantMoment.y += ((centreOfDragYMoment.x - centreOfMass.x) * -localDragForce.z) * dragYMomentMultiplier;
localResultantMoment.y += ((centreOfDragYMoment.z - centreOfMass.z) * localDragForce.x) * dragYMomentMultiplier;
localResultantMoment.z += ((centreOfDragZMoment.x - centreOfMass.x) * localDragForce.y) * dragZMomentMultiplier;
localResultantMoment.z += ((centreOfDragZMoment.y - centreOfMass.y) * -localDragForce.x) * dragZMomentMultiplier;
}
#endregion
//float pDragEndTime = Time.realtimeSinceStartup;
//float aDragStartTime = Time.realtimeSinceStartup;
#region Angular Profile Drag
// Angular drag calculation
if (angularDragFactor > 0f || shipPhysicsModelPhysicsBased)
{
// TODO: Could the length, width and height be precalculated?
// Step 1: We are modelling the drag as if it is occuring on a rectangular prism,
// so calculate the hypothetical length, width and height of that prism from the given areas of each side
dragLength = (float)Math.Sqrt(dragReferenceAreas.x * dragReferenceAreas.y / dragReferenceAreas.z);
dragWidth = dragReferenceAreas.y / dragLength;
dragHeight = dragReferenceAreas.z / dragWidth;
// Step 2: Calculate the angular drag moment on each axis
// TODO: Re-comment this section
// TODO: Could these values be precalculated?
quarticLengthXProj = IntegerPower((dragLength / 2) + centreOfMass.z - centreOfDragYMoment.z, 4) + IntegerPower((dragLength / 2) - centreOfMass.z + centreOfDragYMoment.z, 4);
quarticLengthYProj = IntegerPower((dragLength / 2) + centreOfMass.z - centreOfDragXMoment.z, 4) + IntegerPower((dragLength / 2) - centreOfMass.z + centreOfDragXMoment.z, 4);
quarticWidthYProj = IntegerPower((dragWidth / 2) + centreOfMass.x - centreOfDragZMoment.x, 4) + IntegerPower((dragWidth / 2) - centreOfMass.x + centreOfDragZMoment.x, 4);
quarticWidthZProj = IntegerPower((dragWidth / 2) + centreOfMass.x - centreOfDragYMoment.x, 4) + IntegerPower((dragWidth / 2) - centreOfMass.x + centreOfDragYMoment.x, 4);
quarticHeightXProj = IntegerPower((dragHeight / 2) + centreOfMass.y - centreOfDragZMoment.y, 4) + IntegerPower((dragHeight / 2) - centreOfMass.y + centreOfDragZMoment.y, 4);
quarticHeightZProj = IntegerPower((dragHeight / 2) + centreOfMass.y - centreOfDragXMoment.y, 4) + IntegerPower((dragHeight / 2) - centreOfMass.y + centreOfDragXMoment.y, 4);
if (shipPhysicsModelPhysicsBased) { angularDragMultiplier = 1f; }
else { angularDragMultiplier = (float)Math.Pow(10f, angularDragFactor - 1f); }
// Formula: For a rotating rectangle with the pivot at one end:
// Drag moment = 1/8 * fluid density * angular velocity squared * height * drag coefficient * length to the power of four
// X-axis angular drag
localResultantMoment.x += mediumDensity / 8f * localAngularVelocity.x * localAngularVelocity.x * dragWidth *
dragCoefficients.y * quarticLengthYProj * (localAngularVelocity.x > 0f ? -1f : 1f) * angularDragMultiplier;
localResultantMoment.x += mediumDensity / 8f * localAngularVelocity.x * localAngularVelocity.x * dragWidth *
dragCoefficients.z * quarticHeightZProj * (localAngularVelocity.x > 0f ? -1f : 1f) * angularDragMultiplier;
// Y-axis angular drag
localResultantMoment.y += mediumDensity / 8f * localAngularVelocity.y * localAngularVelocity.y * dragHeight *
dragCoefficients.x * quarticLengthXProj * (localAngularVelocity.y > 0f ? -1f : 1f) * angularDragMultiplier;
localResultantMoment.y += mediumDensity / 8f * localAngularVelocity.y * localAngularVelocity.y * dragHeight *
dragCoefficients.z * quarticWidthZProj * (localAngularVelocity.y > 0f ? -1f : 1f) * angularDragMultiplier;
// Z-axis angular drag
localResultantMoment.z += mediumDensity / 8f * localAngularVelocity.z * localAngularVelocity.z * dragLength *
dragCoefficients.y * quarticWidthYProj * (localAngularVelocity.z > 0f ? -1f : 1f) * angularDragMultiplier;
localResultantMoment.z += mediumDensity / 8f * localAngularVelocity.z * localAngularVelocity.z * dragLength *
dragCoefficients.x * quarticHeightXProj * (localAngularVelocity.z > 0f ? -1f : 1f) * angularDragMultiplier;
}
#endregion
//float aDragEndTime = Time.realtimeSinceStartup;
//float wingsStartTime = Time.realtimeSinceStartup;
// Calculate the "true airspeed" - this is just velocity in forwards direction
aerodynamicTrueAirspeed = localVelocity.z;
#region Wings
// Wing simulation
componentListSize = wingList == null ? 0 : wingList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
// Get the wing we are concerned with
wing = wingList[componentIndex];
// Only calculate lift if some component of the velocity is in the negative airflow direction
if (aerodynamicTrueAirspeed > 0f)
{
//float aoaStartTime = Time.realtimeSinceStartup;
#region Angle of Attack
// OLD UNOPTIMISED CODE. TODO: Delete
////Vector3 wingPlaneNormal = Vector3.Cross(wing.liftDirection, wing.airflowDirection);
//wingPlaneNormal = Vector3.Cross(wing.liftDirection, Vector3.back);
//localVeloInWingPlane = Vector3.ProjectOnPlane(localVelocity, wingPlaneNormal);
//// Is this the right direction?
////float angleOfAttack = Vector3.SignedAngle(-wing.airflowDirection, localVeloInWingPlane, wingPlaneNormal) + wing.angleOfAttack;
//wingAngleOfAttack = Vector3.SignedAngle(Vector3.forward, localVeloInWingPlane, wingPlaneNormal) + wing.angleOfAttack;
// Project the local velocity into the plane containing the lift direction and the forwards (negative airflow) direction
// Take the cross product of lift direction and forwards direction to get the normal of the plane
// Normalise it for the dot product in the next step
//wingPlaneNormal = Vector3.Cross(wing.liftDirectionNormalised, Vector3.forward).normalized;
wingPlaneNormal.x = wing.liftDirectionNormalised.y;
wingPlaneNormal.y = -wing.liftDirectionNormalised.x;
wingPlaneNormal.z = 0f;
wingPlaneNormal.Normalize();
//localVeloInWingPlane = (localVelocity - (Vector3.Dot(localVelocity, wingPlaneNormal) * wingPlaneNormal)).normalized;
// Multiplty the dot product of the local velocity and the wing plane normal with the wing plane normal to
// get the component of the local velocity in the direction of the wing plane normal, then subtract
// this vector from the local velocity to project it into the desired plane
// Then normalise the vector for use in the dot product of the next step
// NOTE: The dot product does not require a z component as the z component of wing plane normal will always be zero,
// as it is perpendicular to the forwards direction
localVeloInWingPlane = (localVelocity - (((localVelocity.x * wingPlaneNormal.x) + (localVelocity.y * wingPlaneNormal.y)) * wingPlaneNormal)).normalized;
// The angle of attack of the wing is equal to:
// The angle between the lift direction and the velocity in the wing plane (computed via arccos of dot product) MINUS
// The angle between the lift direction and the forwards direction PLUS
// The angle of attack of the wing due to camber
// Resultant of the first thing minus the second gives the angle between forwards direction and velocity, with
// forwards above velocity resulting in positive numbers
wingAngleOfAttack = ((float)(Math.Acos(Mathf.Clamp((wing.liftDirectionNormalised.x * localVeloInWingPlane.x) +
(wing.liftDirectionNormalised.y * localVeloInWingPlane.y) +
(wing.liftDirectionNormalised.z * localVeloInWingPlane.z), -1f, 1f)) -
Math.Acos(Mathf.Clamp(wing.liftDirectionNormalised.z, -1f, 1f))) * Mathf.Rad2Deg) +
wing.angleOfAttack;
#endregion
//float aoaEndTime = Time.realtimeSinceStartup;
//float lcStartTime = Time.realtimeSinceStartup;
#region Lift Coefficient
phi0 = (20f * wingStallEffect) - 25f;
phi1 = 15f;
phi2 = 45f - (25f * wingStallEffect);
phi3 = 75f - (50f * wingStallEffect);
//// If angle of attack is not between the min and max wing angles, the wing will stall and not produce any lift
//if (angleOfAttack > -5f && angleOfAttack < 15f)
//{
// // Approximation of lift coefficient, adapted from thin airfoil theory:
// // Lift coefficient = (m * angle of attack) + d
// // Where m = max lift coefficient / (max wing angle - min wing angle) and d = -m * min wing angle
// // Max lift coefficient = 1.5, min wing angle = -5 degrees, max wing angle = 15 degrees
// float liftCoefficient = (0.075f * angleOfAttack) + 0.375f;
//}
// TODO: NEED A COMMENT FOR BELOW THEORY
// Also should look at whether I should just enable/disable stalling
// and just use predetermined values
// Also, possibly stall angle actually comes from chord (wing width)?
// Stall region
if (wingAngleOfAttack < phi0) { liftCoefficient = 0f; }
// Increasing lift region
else if (wingAngleOfAttack < phi1) { liftCoefficient = 1.6f * (wingAngleOfAttack - phi0) / (phi1 - phi0); }
// Maximum lift region
else if (wingAngleOfAttack < phi2) { liftCoefficient = 1.6f; }
// Falloff region
else if (wingAngleOfAttack < phi3) { liftCoefficient = 1.6f * (wingAngleOfAttack - phi3) / (phi2 - phi3); }
// Stall region
else { liftCoefficient = 0f; }
#endregion
//float lcEndTime = Time.realtimeSinceStartup;
//float lidStartTime = Time.realtimeSinceStartup;
#region Lift and Induced Drag
// Lift force magnitude = 0.5 * fluid density * velocity squared * planform wing area * coefficient of lift
liftForceMagnitude = 0.5f * mediumDensity * aerodynamicTrueAirspeed * aerodynamicTrueAirspeed * (wing.span * wing.chord * (float)Math.Cos(wingAngleOfAttack * Mathf.Deg2Rad)) * liftCoefficient;
// Adjust for wing damage
if (!shipDamageModelIsSimple && wing.damageRegionIndex > -1)
{
liftForceMagnitude *= wing.CurrentPerformance;
}
localLiftForce = liftForceMagnitude * wing.liftDirectionNormalised;
// Induced drag force magnitude = 2 * lift squared / (fluid density * velocity squared * pi * wingspan squared)
localInducedDragForce = 2f * liftForceMagnitude * liftForceMagnitude /
(mediumDensity * aerodynamicTrueAirspeed * aerodynamicTrueAirspeed * Mathf.PI * wing.span * wing.span) * Vector3.back;
#endregion
//float lidEndTime = Time.realtimeSinceStartup;
//float forceStartTime = Time.realtimeSinceStartup;
// Add calculated lift and induced drag forces to local resultant force and moment
localResultantForce += localLiftForce + localInducedDragForce;
if (shipPhysicsModelPhysicsBased)
{
localResultantMoment += Vector3.Cross(wing.relativePosition - centreOfMass, localLiftForce + localInducedDragForce);
}
//float forceEndTime = Time.realtimeSinceStartup;
//if (componentIndex == 0)
//{
// Debug.Log("| Angle of attack: " + ((aoaEndTime - aoaStartTime) * 1000f).ToString("0.0000") + " ms | " +
// "Lift coefficient: " + ((lcEndTime - lcStartTime) * 1000f).ToString("0.0000") + " ms | " +
// "Lift and induced drag: " + ((lidEndTime - lidStartTime) * 1000f).ToString("0.0000") + " ms | " +
// "Force and moment: " + ((forceEndTime - forceStartTime) * 1000f).ToString("0.0000") + " ms | ");
//}
}
}
#endregion
//float wingsEndTime = Time.realtimeSinceStartup;
//float controlStartTime = Time.realtimeSinceStartup;
// Control surfaces only available in physics-based mode
if (shipPhysicsModelPhysicsBased)
{
#region Control Surfaces
// Control surface simulation
componentListSize = controlSurfaceList == null ? 0 : controlSurfaceList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
// Get the control surface we are concerned with
controlSurface = controlSurfaceList[componentIndex];
#region Control Surface Type
switch (controlSurface.type)
{
case ControlSurface.ControlSurfaceType.Aileron:
// Aileron
controlSurfaceMovementAxis = Vector3.up;
controlSurfaceInput = momentInput.z * (controlSurface.relativePosition.x > 0f ? 1f : -1f);
break;
case ControlSurface.ControlSurfaceType.Elevator:
// Elevator
controlSurfaceMovementAxis = Vector3.up;
controlSurfaceInput = -momentInput.x;
break;
case ControlSurface.ControlSurfaceType.Rudder:
// Rudder
controlSurfaceMovementAxis = Vector3.right;
controlSurfaceInput = momentInput.y;
break;
case ControlSurface.ControlSurfaceType.AirBrake:
// Air brake
controlSurfaceMovementAxis = Vector3.zero;
controlSurfaceInput = forceInput.z < 0f ? -forceInput.z : 0f;
break;
#if UNITY_EDITOR
default:
// Custom (TODO)
Debug.Log("Ship - Custom control surfaces not supported yet.");
break;
#endif
}
#endregion
// When there is no input the control surface does not apply any force
if (controlSurfaceInput != 0f)
{
#region Calculate Lift and Drag Forces
// Calculate the angle the control surface is inclined at
// Absolute value of controlSurfaceInput is used as we only want magnitude - direction is added in a later step
controlSurfaceAngle = Mathf.PI / 2f * (controlSurfaceInput > 0f ? controlSurfaceInput : -controlSurfaceInput);
// Calculate the magnitude of the change (delta) in lift and drag caused by the inclination of the control surface
// This is essentially the change in planform area (for lift) and the change in profile area (for drag)
// multiplied by the usual aerodynamic formulae for each
// TODO: Should probably work out something mildly more accurate for lift coefficient (currently is just 1.6)
// TODO: Should probably have something for a drag coefficient as well (currently is just 2)
// Then convert the forces into vectors by multiplying by their directions
// TODO: Include relative position based on inclination
// - I think this means the position of the centre of the CS adjusted for where it has been rotated to?
if (controlSurfaceMovementAxis != Vector3.zero)
{
controlSurfaceLiftDelta = (1f - (float)Math.Cos(controlSurfaceAngle)) * 0.5f * mediumDensity *
aerodynamicTrueAirspeed * aerodynamicTrueAirspeed * controlSurface.chord * controlSurface.span * 1.6f;
}
else { controlSurfaceLiftDelta = 0f; }
controlSurfaceDragDelta = (float)Math.Sin(controlSurfaceAngle) * 0.5f * mediumDensity *
aerodynamicTrueAirspeed * aerodynamicTrueAirspeed * controlSurface.chord * controlSurface.span * 2f;
// Adjust for control surface damage
if (!shipDamageModelIsSimple && controlSurface.damageRegionIndex > -1)
{
controlSurfaceLiftDelta *= controlSurface.CurrentPerformance;
controlSurfaceDragDelta *= controlSurface.CurrentPerformance;
}
localLiftForce = controlSurfaceLiftDelta * (controlSurfaceInput > 0f ? -1f : 1f) * controlSurfaceMovementAxis;
localDragForce = controlSurfaceDragDelta * (aerodynamicTrueAirspeed > 0f ? 1f : -1f) * Vector3.back;
#endregion
// Adjust relative position to take into account current inclination of control surface
controlSurfaceRelativePosition = controlSurface.relativePosition + (controlSurfaceMovementAxis *
controlSurface.chord * 0.5f * (float)Math.Sin(controlSurfaceAngle));
// Add calculated lift and drag forces to resultant force and moment
localResultantForce += localLiftForce + localDragForce;
localResultantMoment += Vector3.Cross(controlSurfaceRelativePosition - centreOfMass, localLiftForce + localDragForce);
}
}
#endregion
}
//float controlEndTime = Time.realtimeSinceStartup;
//Debug.Log("| Profile Drag: " + ((pDragEndTime - pDragStartTime) * 1000f).ToString("0.0000") + " ms | " +
// "Angular Drag: " + ((aDragEndTime - aDragStartTime) * 1000f).ToString("0.0000") + " ms | " +
// "Wings: " + ((wingsEndTime - wingsStartTime) * 1000f).ToString("0.0000") + " ms | " +
// "Control Surfaces: " + ((controlEndTime - controlStartTime) * 1000f).ToString("0.0000") + " ms | ");
}
#endregion
#if SSC_SHIP_DEBUG
float aeroEndTime = Time.realtimeSinceStartup;
float arcadeStartTime = Time.realtimeSinceStartup;
#endif
#region Arcade Physics Adjustments
if (!shipPhysicsModelPhysicsBased)
{
// Apply moments to match pitch, yaw and roll inputs, as well as for various arcade adjustments
// These include rotational flight assist and target pitch/roll moment
// Multiplication by inertia tensor is used so that we can use acceleration parameters instead of force parameters
localResultantMoment.x += ((momentInput.x * arcadePitchAcceleration) + arcadeMomentVector.x) * Mathf.Deg2Rad * rBodyInertiaTensor.x;
localResultantMoment.y += ((momentInput.y * arcadeYawAcceleration) + arcadeMomentVector.y) * Mathf.Deg2Rad * rBodyInertiaTensor.y;
localResultantMoment.z += ((momentInput.z * arcadeRollAcceleration) + arcadeMomentVector.z) * Mathf.Deg2Rad * rBodyInertiaTensor.z * -1f;
// TODO: Currently this doesn't take into account the force already being applied by the ship,
// calculated prior to this point
// Should it do that?
if (stickToGroundSurfaceEnabled)
{
// Calculate the limits for input for ground matching
float maxGroundDistInput = maxGroundMatchAcceleration;
if (useGroundMatchSmoothing)
{
// Previous values (for last two arguments): 50f, 2f
maxGroundDistInput = DampedMaxAccelerationInput(currentPerpendicularGroundDist, targetGroundDistance,
minGroundDistance, maxGroundDistance, centralMaxGroundMatchAcceleration, maxGroundMatchAcceleration, 200f, 0.5f);
}
// Set input limits
groundDistPIDController.SetInputLimits(-maxGroundDistInput, maxGroundDistInput);
// Get input from ground distance PID controller
groundDistInput = groundDistPIDController.RequiredInput(targetGroundDistance, currentPerpendicularGroundDist, _deltaTime);
//Debug.Log("Ground dist input: " + groundDistInput.ToString("000000.0"));
//Debug.Log("Current ground dist: " + currentPerpendicularGroundDist.ToString("00.00"));
// Are we preventing an arcade model ship from going below the target (minimum) distnace?
if (avoidGroundSurface)
{
// Only override user input if the ship is going below the targetGroundDistance
stickToGroundSurfaceEnabled = groundDistInput > 0f;
}
}
if (stickToGroundSurfaceEnabled)
{
// Apply turning force counteracting velocity on x axis if pilot releases the input
// or if input is in direction opposing velocity
if ((forceInput.x > 0f) == (localVelocity.x < 0f) || forceInput.x == 0f)
{
// The force also includes a component to counteract gravity on this axis
arcadeForceVector.x = -((localVelocity.x * 0.5f / _deltaTime) + localGravityAcceleration.x);
}
else { arcadeForceVector.x = 0f; }
// When we are sticking to the ground surface don't apply turning force on y axis,
// as this force should be primarily handled by the force keeping the ship at the
// target distance from the ground
arcadeForceVector.y = 0f;
// TODO: Maybe want to have an option to allow force to act on z as well (resulting in very arcade-like handling)
arcadeForceVector.z = 0f;
// Clamp the magnitude of the turning force vector so that the force applied does not exceed
// the maximum on-ground turning acceleration. Multiply by mass to convert the acceleration into a force
arcadeForceVector = Vector3.ClampMagnitude(arcadeForceVector, arcadeMaxGroundTurningAcceleration) * mass;
// Moved above in 1.2.6
//// Calculate the limits for input for ground matching
//float maxGroundDistInput = maxGroundMatchAcceleration;
//if (useGroundMatchSmoothing)
//{
// // Previous values (for last two arguments): 50f, 2f
// maxGroundDistInput = DampedMaxAccelerationInput(currentPerpendicularGroundDist, targetGroundDistance,
// minGroundDistance, maxGroundDistance, centralMaxGroundMatchAcceleration, maxGroundMatchAcceleration, 200f, 0.5f);
//}
//// Set input limits
//groundDistPIDController.SetInputLimits(-maxGroundDistInput, maxGroundDistInput);
// Add a force acting in the direction of the ground normal to keep the ship at a target distance
// from the ground (the magnitude of the force is calculated by the associated PID controller)
arcadeForceVector += trfmInvRot * worldTargetPlaneNormal * groundDistInput * mass;
// pre-v1.2.6 (calculated above in 1.2.6+ as groundDistInput variable)
//arcadeForceVector += trfmInvRot * worldTargetPlaneNormal *
// groundDistPIDController.RequiredInput(targetGroundDistance, currentPerpendicularGroundDist, _deltaTime) * mass;
//localResultantForce.y += stickToGroundAcc * mass;
//Debug.Log("Dist: " + currentPerpendicularGroundDist.ToString("00.00") + " m, acc: " + stickToGroundAcc.ToString("000.00") + "m/s^2");
//Debug.Log("Speed: " + speed.ToString("0000") + " m/s");
}
else
{
// Apply turning force counteracting velocity on x and y axes if pilot releases the input
// or if input is in direction opposing velocity
if ((forceInput.x > 0f) == (localVelocity.x < 0f) || forceInput.x == 0f)
{
// The force also includes a component to counteract gravity on this axis
arcadeForceVector.x = -((localVelocity.x * 0.5f / _deltaTime) + localGravityAcceleration.x);
}
else { arcadeForceVector.x = 0f; }
if ((forceInput.y > 0f) == (localVelocity.y < 0f) || forceInput.y == 0f)
{
// The force also includes a component to counteract gravity on this axis
arcadeForceVector.y = -((localVelocity.y * 0.5f / _deltaTime) + localGravityAcceleration.y);
}
else { arcadeForceVector.y = 0f; }
// Maybe want to have an option to allow force to act on z as well (resulting in very arcade-like handling)
arcadeForceVector.z = 0f;
// Clamp the magnitude of the turning force vector so that the force applied does not exceed
// the maximum in-flight turning acceleration. Multiply by mass to convert the acceleration into a force (f = ma)
arcadeForceVector = Vector3.ClampMagnitude(arcadeForceVector, arcadeMaxFlightTurningAcceleration) * mass;
}
// Braking component for arcade mode - active when moving forward and braking
if (arcadeUseBrakeComponent && localVelocity.z > 0f && forceInput.z < 0f)
{
// Calculate magnitude of braking force using drag formula
arcadeBrakeForceMagnitude = 0.5f * (arcadeBrakeIgnoreMediumDensity ? 1f : mediumDensity) * localVelocity.z * localVelocity.z * arcadeBrakeStrength * -forceInput.z;
// Calculate min braking force (f = ma)
arcadeBrakeForceMinMagnitude = arcadeBrakeMinAcceleration * mass;
// Make sure min braking force doesn't overcompensate and cause the ship to start moving backwards
if (arcadeBrakeForceMinMagnitude > localVelocity.z / _deltaTime * mass)
{
arcadeBrakeForceMinMagnitude = localVelocity.z / _deltaTime * mass;
}
// Add braking force or min braking force - whichever is larger
arcadeForceVector.z -= arcadeBrakeForceMagnitude > arcadeBrakeForceMinMagnitude ? arcadeBrakeForceMagnitude : arcadeBrakeForceMinMagnitude;
}
// Add the calculated arcade force to the local resultant force
localResultantForce += arcadeForceVector;
}
#endregion
#if SSC_SHIP_DEBUG
float arcadeEndTime = Time.realtimeSinceStartup;
#endif
// Remember time of this fixed update
lastFixedUpdateTime = Time.time;
#if SSC_SHIP_DEBUG
//Debug.Log("| Init: " + ((initEndTime - initStartTime) * 1000f).ToString("0.0000") + " ms | " +
// "Ground: " + ((groundEndTime - groundStartTime) * 1000f).ToString("0.0000") + " ms | " +
// "Input: " + ((inputEndTime - inputStartTime) * 1000f).ToString("0.0000") + " ms | " +
// "Thrusters: " + ((thrusterEndTime - thrusterStartTime) * 1000f).ToString("0.0000") + " ms | " +
// "Aero: " + ((aeroEndTime - aeroStartTime) * 1000f).ToString("0.0000") + " ms | " +
// "Arcade: " + ((arcadeEndTime - arcadeStartTime) * 1000f).ToString("0.0000") + " ms | " +
// "Total: " + ((arcadeEndTime - initStartTime) * 1000f).ToString("0.0000") + " ms | ");
#endif
}
#endregion
#region Update Weapons And Damage
/// <summary>
/// Update weapons and damage information for this ship. Should be called during Update(), and have
/// UpdatePositionAndMovementData() called prior to it.
/// NOTE: We often hardcode the weaponType int rather than looking up the enum for the sake of performance.
/// </summary>
/// <param name="shipControllerManager"></param>
public void UpdateWeaponsAndDamage(SSCManager shipControllerManager)
{
#region Initialisation
float _deltaTime = Time.deltaTime;
// Get the ship damage model
shipDamageModelIsSimple = shipDamageModel == ShipDamageModel.Simple;
// Update the local reference, which is used also in MoveBeam()
if (sscManager == null) { sscManager = shipControllerManager; }
#endregion
#region Weapons
componentListSize = weaponList == null ? 0 : weaponList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
// Get the weapon we are concerned with
weapon = weaponList[componentIndex];
if (weapon == null) { continue; }
// Check that the weapon has had a projectile ID or beam ID assigned
// Assumes that the IDs have been correctly assigned based on the weaponType.
if (weapon.projectilePrefabID >= 0 || weapon.beamPrefabID >= 0)
{
// Lookup the enumeration once
weaponTypeInt = weapon.weaponTypeInt;
weaponFiringButtonInt = (int)weapon.firingButton;
// Does the weapon need to cool down??
weapon.ManageHeat(_deltaTime, 0f);
// If the weapon is not connected to a firing mechanism we can probably ignore the reload timer
// Weapons with no health or performance cannot aim, reload, move turrets, or fire.
if (weaponFiringButtonInt > 0 && weapon.health > 0f && weapon.currentPerformance > 0f)
{
if (weaponTypeInt == Weapon.TurretProjectileInt || weaponTypeInt == Weapon.TurretBeamInt) { weapon.MoveTurret(worldVelocity, false); }
// Does the beam weapon need charging?
if ((weaponTypeInt == Weapon.FixedBeamInt || weaponTypeInt == Weapon.TurretBeamInt) && weapon.rechargeTime > 0f && weapon.chargeAmount < 1f)
{
weapon.chargeAmount += _deltaTime * 1f / weapon.rechargeTime;
if (weapon.chargeAmount > 1f) { weapon.chargeAmount = 1f; }
}
// Check if this projectile weapon is reloading or not
// Check if this beam weapon is powering-up or not
if (weapon.reloadTimer > 0f)
{
// If reloading (or powering-up), update reload timer
weapon.reloadTimer -= _deltaTime;
}
// Check if this weapon is damaged or not
else if (shipDamageModelIsSimple || weapon.damageRegionIndex < 0 || weapon.Health > 0f)
{
// If not reloading and not damaged, check if we should fire the weapon or not
// For autofiring weapons, this will return false.
bool isReadyToFire = (pilotPrimaryFireInput && weaponFiringButtonInt == weaponPrimaryFiringInt) || (pilotSecondaryFireInput && weaponFiringButtonInt == weaponSecondaryFiringInt);
// If this is auto-firing turret check if it is ready to fire
if (weaponFiringButtonInt == weaponAutoFiringInt && (weaponTypeInt == Weapon.TurretProjectileInt || weaponTypeInt == Weapon.TurretBeamInt))
{
// Is turret locked on target and in direct line of sight?
// NOTE: If check LoS is enabled, it will still fire if another enemy is between the turret and the weapon.target.
isReadyToFire = weapon.isLockedOnTarget && (!weapon.checkLineOfSight || WeaponHasLineOfSight(weapon));
// TODO - Is target in range?
}
// If not reloading and not damaged, check if we should fire the weapon or not
if (isReadyToFire && weapon.ammunition != 0)
{
// ==============================================================================
// NOTE: We need to do most of these steps also in MoveBeam(..). So the commented
// out methods below called in MoveBeam(..)
// ==============================================================================
// Get base weapon world position (not accounting for relative fire position)
//weaponWorldBasePosition = GetWeaponWorldBasePosition(weapon);
weaponWorldBasePosition = (trfmRight * weapon.relativePosition.x) +
(trfmUp * weapon.relativePosition.y) +
(trfmFwd * weapon.relativePosition.z) +
trfmPos;
// Get relative fire direction
weaponRelativeFireDirection = weapon.fireDirectionNormalised;
// If this is a turret, adjust relative fire direction based on turret rotation
if (weaponTypeInt == Weapon.TurretProjectileInt || weaponTypeInt == Weapon.TurretBeamInt)
{
// (turret rotation less ship rotate) - (original turret rotation less ship rotation) + relative fire direction
weaponRelativeFireDirection = (trfmInvRot * weapon.turretPivotX.rotation) * weapon.intPivotYInvRot * weaponRelativeFireDirection;
}
// Get weapon world fire direction
weaponWorldFireDirection = (trfmRight * weaponRelativeFireDirection.x) +
(trfmUp * weaponRelativeFireDirection.y) +
(trfmFwd * weaponRelativeFireDirection.z);
//weaponWorldFireDirection = GetWeaponWorldFireDirection(weapon);
// Start the firing cycle with no heat generated
float heatValue = 0f;
bool hasFired = false;
// Loop through all fire positions
int firePositionListCount = weapon.isMultipleFirePositions ? weapon.firePositionList.Count : 1;
for (int fp = 0; fp < firePositionListCount; fp++)
{
// Only fire if there is unlimited ammunition (-1) or greater than 0 projectiles available
if (weapon.ammunition != 0)
{
// If not unlimited ammo, decrement the quantity available
if (weapon.ammunition > 0) { weapon.ammunition--; }
// Check if there are multiple fire positions
if (weapon.isMultipleFirePositions)
{
// Get relative fire position
weaponRelativeFirePosition = weapon.firePositionList[fp];
}
else
{
// If there is only one fire position, relative position must be the zero vector
weaponRelativeFirePosition.x = 0f;
weaponRelativeFirePosition.y = 0f;
weaponRelativeFirePosition.z = 0f;
}
// If this is a turret, adjust relative fire position based on turret rotation
if (weaponTypeInt == Weapon.TurretProjectileInt || weaponTypeInt == Weapon.TurretBeamInt)
{
weaponRelativeFirePosition = (trfmInvRot * weapon.turretPivotX.rotation) * weaponRelativeFirePosition;
}
// Get weapon world fire position
weaponWorldFirePosition = weaponWorldBasePosition +
(trfmRight * weaponRelativeFirePosition.x) +
(trfmUp * weaponRelativeFirePosition.y) +
(trfmFwd * weaponRelativeFirePosition.z);
//weaponWorldFirePosition = GetWeaponWorldFirePosition(weapon, weaponWorldBasePosition, weaponRelativeFirePosition);
if (weaponTypeInt == Weapon.FixedBeamInt || weaponTypeInt == Weapon.TurretBeamInt)
{
// if the sequence number is 0, it means it is not active
if (weapon.beamItemKeyList[fp].beamSequenceNumber == 0)
{
InstantiateBeamParameters ibParms = new InstantiateBeamParameters()
{
beamPrefabID = weapon.beamPrefabID,
position = weaponWorldFirePosition,
fwdDirection = weaponWorldFireDirection,
upDirection = trfmUp,
shipId = shipId,
squadronId = squadronId,
weaponIndex = componentIndex,
firePositionIndex = fp,
beamSequenceNumber = 0,
beamPoolListIndex = -1
};
// Create a beam using the ship control Manager (SSCManager)
// Pass InstantiateBeamParameters by reference so we can get the beam index and sequence number back
BeamModule beamModule = shipControllerManager.InstantiateBeam(ref ibParms);
if (beamModule != null)
{
beamModule.callbackOnMove = MoveBeam;
// Retrieve the unique identifiers for the beam instance
weapon.beamItemKeyList[fp] = new SSCBeamItemKey(weapon.beamPrefabID, ibParms.beamPoolListIndex, ibParms.beamSequenceNumber);
// Immediately update the beam position (required for pooled beams that have previously been used)
MoveBeam(beamModule);
hasFired = true;
// Was a poolable muzzle fx spawned?
if (beamModule.muzzleEffectsItemKey.effectsObjectSequenceNumber > 0)
{
// Only get the transform if the muzzle EffectsModule has Is Reparented enabled.
Transform muzzleFXTrfm = shipControllerManager.GetEffectsObjectTransform(beamModule.muzzleEffectsItemKey.effectsObjectTemplateListIndex, beamModule.muzzleEffectsItemKey.effectsObjectPoolListIndex, true);
if (muzzleFXTrfm != null)
{
muzzleFXTrfm.SetParent(beamModule.transform);
}
}
}
}
}
else
{
// Create a new projectile using the ship controller Manager (SSCManager)
// Velocity is world velocity of ship plus relative velocity of weapon due to angular velocity
InstantiateProjectileParameters ipParms = new InstantiateProjectileParameters()
{
projectilePrefabID = weapon.projectilePrefabID,
position = weaponWorldFirePosition,
fwdDirection = weaponWorldFireDirection,
upDirection = trfmUp,
weaponVelocity = worldVelocity + Vector3.Cross(worldAngularVelocity, weaponWorldFirePosition - trfmPos),
gravity = gravitationalAcceleration,
gravityDirection = gravityDirection,
shipId = shipId,
squadronId = squadronId,
targetShip = weapon.isProjectileKGuideToTarget ? weapon.targetShip : null,
targetGameObject = weapon.isProjectileKGuideToTarget ? weapon.target : null,
targetguidHash = weapon.isProjectileKGuideToTarget ? weapon.targetguidHash : 0,
};
shipControllerManager.InstantiateProjectile(ref ipParms);
// For now, assume projectile was instantiated
// Heat value is inversely proportional to the firing interval (reload time)
if (weapon.reloadTime > 0f) { heatValue += 1f / weapon.reloadTime; };
hasFired = true;
// Was a poolable muzzle fx spawned?
if (ipParms.muzzleEffectsObjectPoolListIndex >= 0)
{
// Only get the transform if the muzzle EffectsModule has Is Reparented enabled.
Transform muzzleFXTrfm = shipControllerManager.GetEffectsObjectTransform(ipParms.muzzleEffectsObjectPrefabID, ipParms.muzzleEffectsObjectPoolListIndex, true);
if (muzzleFXTrfm != null)
{
if (weaponTypeInt == Weapon.TurretProjectileInt)
{
muzzleFXTrfm.SetParent(weapon.turretPivotX);
}
else
{
// This may be risky as it could create a dependency that
// causes GC and/or circular reference issues when the ShipControlModule is destroyed.
// Might need a better method of doing this in the future.
muzzleFXTrfm.SetParent(shipTransform);
}
}
}
}
// Set reload timer to reload time
weapon.reloadTimer = weapon.reloadTime;
// Did we just run out of ammo?
if (weapon.ammunition == 0 && callbackOnWeaponNoAmmo != null)
{
callbackOnWeaponNoAmmo.Invoke(this, weapon);
}
}
}
if (heatValue > 0f) { weapon.ManageHeat(_deltaTime, heatValue); }
// If the ship has a callback configured for the weapon, and it
// has fired at least one fire point, invoke the callback.
if (hasFired && callbackOnWeaponFired != null)
{
callbackOnWeaponFired.Invoke(this, weapon);
}
}
}
}
}
}
#endregion
#region Damage
if (!Destroyed())
{
if (respawningMode == RespawningMode.RespawnAtLastPosition)
{
// Update current respawn position and rotation
currentRespawnPosition = trfmPos;
currentRespawnRotation = trfmRot;
// Increment collision respawn position timer
collisionRespawnPositionTimer += _deltaTime;
// When timer reaches the interval amount...
if (collisionRespawnPositionTimer > collisionRespawnPositionDelay)
{
// Update current respawn position/rotation (from what was next)
currentCollisionRespawnPosition = nextCollisionRespawnPosition;
currentCollisionRespawnRotation = nextCollisionRespawnRotation;
// Set next respawn position/rotation from current position/rotation
nextCollisionRespawnPosition = trfmPos;
nextCollisionRespawnRotation = trfmRot;
// Reset the timer
collisionRespawnPositionTimer = 0f;
}
}
}
#endregion
}
#endregion
#endregion
#region Public API Methods
#region Damage API Methods
/// <summary>
/// When attaching an object to the ship, call this method for each non-trigger collider.
/// It is automatically called when using VR hands to avoid them colliding with the ship
/// and causing damage.
/// </summary>
/// <param name="colliderToAttach"></param>
public void AttachCollider (Collider colliderToAttach)
{
if (colliderToAttach != null && !colliderToAttach.isTrigger)
{
attachedCollisionColliders.Add(colliderToAttach.GetInstanceID());
}
}
/// <summary>
/// When attaching an object to the ship, call this method with an array of non-trigger collider.
/// It is automatically called when using VR hands to avoid them colliding with the ship
/// and causing damage. See also AttachCollider(..) and DetachCollider(..).
/// </summary>
/// <param name="collidersToAttach"></param>
public void AttachColliders (Collider[] collidersToAttach)
{
int numAttachedColliders = collidersToAttach == null ? 0 : collidersToAttach.Length;
for (int colIdx = 0; colIdx < numAttachedColliders; colIdx++)
{
Collider attachCollider = collidersToAttach[colIdx];
if (attachCollider.enabled && !attachCollider.isTrigger) { AttachCollider(attachCollider); }
}
}
/// <summary>
/// When detaching or removing an object from the ship, call this method for each non-trigger collider.
/// This is only required if it was first registered with AttachCollider(..).
/// USAGE: DetachCollider (collider.GetInstanceID())
/// </summary>
/// <param name="colliderID"></param>
public void DetachCollider (int colliderID)
{
attachedCollisionColliders.Remove(colliderID);
}
/// <summary>
/// When detaching or removing an object from the ship, call this method with an array
/// of non-trigger colliders. This is only required if they were first attached.
/// </summary>
/// <param name="collidersToDetach"></param>
public void DetachColliders (Collider[] collidersToDetach)
{
int numAttachedColliders = collidersToDetach == null ? 0 : collidersToDetach.Length;
for (int colIdx = 0; colIdx < numAttachedColliders; colIdx++)
{
Collider attachCollider = collidersToDetach[colIdx];
if (attachCollider != null && attachCollider.enabled) { DetachCollider(attachCollider.GetInstanceID()); }
}
}
/// <summary>
/// Get the localised damage region with guidHash in the list of regions.
/// The ship must be initialised.
/// </summary>
/// <param name="guidHash"></param>
/// <returns></returns>
public DamageRegion GetDamageRegion(int guidHash)
{
DamageRegion damageRegion = null;
if (guidHash != 0 && shipDamageModel == ShipDamageModel.Localised)
{
// Attempt to find a matching guidHash
for (int dmIdx = 0; dmIdx < numLocalisedDamageRegions; dmIdx++)
{
if (localisedDamageRegionList[dmIdx].guidHash == guidHash)
{
damageRegion = localisedDamageRegionList[dmIdx]; break;
}
}
}
return damageRegion;
}
/// <summary>
/// Get the localised damage region with the zero-based index in the list of regions.
/// The ship must be initialised.
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public DamageRegion GetDamageRegionByIndex(int index)
{
if (shipDamageModel == ShipDamageModel.Localised && index >= 0 && index < numLocalisedDamageRegions)
{
return localisedDamageRegionList[index];
}
else { return null; }
}
/// <summary>
/// Get the zero-based index of a local damage region in the ship given the damage region name.
/// Returns -1 if not found or the Damage Model is not Localised.
/// Use this sparingly as it will incur garabage. Always declare the parameter as a static readonly variable.
/// Usage:
/// private static readonly string EngineDamageRegionName = "Engines";
/// ..
/// int drIdx = GetDamageRegionIndexByName(EngineDamageRegionName);
/// DamageRegion damageRegion = GetDamageRegionByIndex(drIdx);
/// </summary>
/// <param name="damageRegionName"></param>
/// <returns></returns>
public int GetDamageRegionIndexByName(string damageRegionName)
{
if (shipDamageModel == ShipDamageModel.Localised && localisedDamageRegionList != null)
{
return localisedDamageRegionList.FindIndex(dr => dr.name == damageRegionName);
}
else { return -1; }
}
/// <summary>
/// Get the world space central position of the localised damage region
/// with the given guidHash. If the ship is not using the Localised damage model
/// or a damage region with guidHash cannot be found, this returns the world space
/// position of the ship.
/// The ship must be initialised.
/// </summary>
/// <param name="guidHash"></param>
/// <returns></returns>
public Vector3 GetDamageRegionWSPosition(int guidHash)
{
DamageRegion damageRegion = GetDamageRegion(guidHash);
if (damageRegion != null)
{
return (trfmRight * damageRegion.relativePosition.x) +
(trfmUp * damageRegion.relativePosition.y) +
(trfmFwd * damageRegion.relativePosition.z) +
trfmPos;
}
else { return TransformPosition; }
}
/// <summary>
/// Get the world space central position of the damage region.
/// The ship must be initialised.
/// </summary>
/// <param name="damageRegion"></param>
/// <returns></returns>
public Vector3 GetDamageRegionWSPosition(DamageRegion damageRegion)
{
return (trfmRight * damageRegion.relativePosition.x) +
(trfmUp * damageRegion.relativePosition.y) +
(trfmFwd * damageRegion.relativePosition.z) +
trfmPos;
}
/// <summary>
/// Is this world space point on the ship, currently shielded?
/// If the main damage region is invincible, it will always return true.
/// If the ShipDamageModel is NOT Localised, the worldSpacePoint is ignored.
/// </summary>
/// <param name="worldSpacePoint"></param>
/// <returns></returns>
public bool HasActiveShield (Vector3 worldSpacePoint)
{
bool isShielded = false;
if (mainDamageRegion.isInvincible) { isShielded = true; }
else if (shipDamageModel != ShipDamageModel.Localised)
{
isShielded = mainDamageRegion.useShielding && mainDamageRegion.ShieldHealth > 0f;
}
else
{
// Determine which damage region was hit
int numDamageRegions = localisedDamageRegionList.Count + 1;
// Loop through all damage regions
DamageRegion thisDamageRegion;
// Get damage position in local space (calc once outside the loop)
Vector3 localDamagePosition = trfmInvRot * (worldSpacePoint - trfmPos);
for (int i = 0; i < numDamageRegions; i++)
{
thisDamageRegion = i == 0 ? mainDamageRegion : localisedDamageRegionList[i - 1];
if (thisDamageRegion.useShielding && thisDamageRegion.ShieldHealth > 0f && thisDamageRegion.IsHit(localDamagePosition))
{
isShielded = true;
break;
}
}
}
return isShielded;
}
/// <summary>
/// Check if a world-space point is within the volume area of a damage region.
/// </summary>
/// <param name="damageRegion"></param>
/// <param name="worldSpacePoint"></param>
/// <returns></returns>
public bool IsPointInDamageRegion (DamageRegion damageRegion, Vector3 worldSpacePoint)
{
return damageRegion == null ? false : damageRegion.IsHit(trfmInvRot * (worldSpacePoint - trfmPos));
}
/// <summary>
/// Make the whole ship invincible to damage.
/// For individual damageRegions change the isInvisible value on the localised region.
/// </summary>
public void MakeShipInvincible()
{
mainDamageRegion.isInvincible = true;
}
/// <summary>
/// Make the whole ship vincible to damage. When hit, the ship or shields will take damage.
/// For individual damageRegions change the isInvisible value on the localised region.
/// </summary>
public void MakeShipVincible()
{
mainDamageRegion.isInvincible = false;
}
/// <summary>
/// Resets health data for the ship. Used when initialising and respawning the ship.
/// </summary>
/// <returns></returns>
public void ResetHealth()
{
// Reset health value for the damage region
mainDamageRegion.Health = mainDamageRegion.startingHealth;
// Reset shield health value for the damage region
mainDamageRegion.ShieldHealth = mainDamageRegion.shieldingAmount;
mainDamageRegion.shieldRechargeDelayTimer = 0f;
mainDamageRegion.isDestructObjectActivated = false;
mainDamageRegion.isDestroyed = false;
damageCameraShakeAmountRequired = 0f;
if (!shipDamageModelIsSimple)
{
// Reset health value for each component
componentListSize = thrusterList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
thrusterList[componentIndex].Repair();
}
componentListSize = wingList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
wingList[componentIndex].Health = wingList[componentIndex].startingHealth;
}
componentListSize = controlSurfaceList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
controlSurfaceList[componentIndex].Health = controlSurfaceList[componentIndex].startingHealth;
}
componentListSize = weaponList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
weaponList[componentIndex].Repair();
}
if (shipDamageModel == ShipDamageModel.Localised)
{
// For each damage region:
// reset health value, shield health value, effects object or destruct instantiated flags, and child tranform
for (componentIndex = 0; componentIndex < numLocalisedDamageRegions; componentIndex++)
{
DamageRegion _damageRegion = localisedDamageRegionList[componentIndex];
_damageRegion.Health = localisedDamageRegionList[componentIndex].startingHealth;
_damageRegion.ShieldHealth = localisedDamageRegionList[componentIndex].shieldingAmount;
_damageRegion.shieldRechargeDelayTimer = 0f;
_damageRegion.isDestructionEffectsObjectInstantiated = false;
_damageRegion.isDestructObjectActivated = false;
_damageRegion.isDestroyed = false;
// if there is one, reactivate the transform for this region.
if (_damageRegion.regionChildTransform != null && !_damageRegion.regionChildTransform.gameObject.activeSelf)
{
_damageRegion.regionChildTransform.gameObject.SetActive(true);
}
}
}
}
if (callbackOnDamage != null) { callbackOnDamage(mainDamageRegion.Health); }
}
/// <summary>
/// Typically used when ShipDamageModel is Simple or Progressive, add health to the ship.
/// If isAffectShield is true, and the health reaches the maximum configured, excess health will
/// be applied to the shield for the specified DamageRegion. For Progressive Damage, health is
/// also added to components that have Use Progressive Damage enabled.
/// </summary>
/// <param name="healthAmount"></param>
/// <param name="isAffectShield"></param>
public void AddHealth(float healthAmount, bool isAffectShield)
{
AddHealth(mainDamageRegion, healthAmount, isAffectShield);
}
/// <summary>
/// Add health to a specific DamageRegion.
/// If isAffectShield is true, and the health reaches the maximum configured, excess health will
/// be applied to the shield for the specified DamageRegion. For Progressive Damage, health is
/// also added to components that have Use Progressive Damage enabled.
/// NOTE: -ve values are ignored. To incur damage use the ApplyNormalDamage or ApplyCollisionDamage
/// API methods.
/// </summary>
/// <param name="damageRegion"></param>
/// <param name="healthAmount"></param>
/// <param name="isAffectShield"></param>
public void AddHealth(DamageRegion damageRegion, float healthAmount, bool isAffectShield)
{
if (damageRegion != null && healthAmount > 0f)
{
float health = damageRegion.Health;
if (health < 0f) { health = healthAmount; }
else { health += healthAmount; }
if (health > damageRegion.startingHealth)
{
if (isAffectShield && damageRegion.useShielding)
{
float newShieldHealth = 0f;
// When shielding is -ve (e.g. -0.01 when it has been used up) set the shielding amount rather than adding it
if (damageRegion.ShieldHealth < 0f) { newShieldHealth = health - damageRegion.startingHealth; }
else { newShieldHealth = damageRegion.ShieldHealth + health - damageRegion.startingHealth; }
// Cap shielding to maximum permitted.
if (newShieldHealth > damageRegion.shieldingAmount) { newShieldHealth = damageRegion.shieldingAmount; }
damageRegion.ShieldHealth = newShieldHealth;
}
// Cap health to maximum permitted
health = damageRegion.startingHealth;
}
damageRegion.Health = health;
// Not sure if this is correct... why do we do this??
damageRegion.isDestructionEffectsObjectInstantiated = false;
// Use !shipDamageModelIsSimple first to avoid always having to lookup the enumeration
if (!shipDamageModelIsSimple)
{
int damageRegionIndex = GetDamageRegionIndex(damageRegion);
// Apply health to each of the components
if (damageRegionIndex >= 0)
{
// For Progressive, a damageRegionIndex of 0 on the component means Use Progressive Damage.
// If -1, the component doesn't use Progressive damage.
// For localised damage, the damageRegionIndex needs to match the damage region that health is being added to.
// Add health to Thrusters
componentListSize = thrusterList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
// For Progressive, a region index of 0 means Use Progressive Damage.
if (thrusterList[componentIndex].damageRegionIndex == damageRegionIndex)
{
health = thrusterList[componentIndex].Health;
if (health < 0f) { health = healthAmount; }
else { health += healthAmount; }
if (health > thrusterList[componentIndex].startingHealth) { health = thrusterList[componentIndex].startingHealth; }
// Only set the health value once for a given thruster
thrusterList[componentIndex].Health = health;
}
}
//Add health to Wings
componentListSize = wingList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
// For Progressive, a region index of 0 means Use Progressive Damage
if (wingList[componentIndex].damageRegionIndex == damageRegionIndex)
{
health = wingList[componentIndex].Health;
if (health < 0f) { health = healthAmount; }
else { health += healthAmount; }
if (health > wingList[componentIndex].startingHealth) { health = wingList[componentIndex].startingHealth; }
// Only set the health value once for a given wing
wingList[componentIndex].Health = health;
}
}
// Add health to Control Surfaces
componentListSize = controlSurfaceList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
// For Progressive, a region index of 0 means Use Progressive Damage
if (controlSurfaceList[componentIndex].damageRegionIndex == damageRegionIndex)
{
health = controlSurfaceList[componentIndex].Health;
if (health < 0f) { health = healthAmount; }
else { health += healthAmount; }
if (health > controlSurfaceList[componentIndex].startingHealth) { health = controlSurfaceList[componentIndex].startingHealth; }
// Only set the health value once for a given Control Surface
controlSurfaceList[componentIndex].Health = health;
}
}
// Add health to Weapons
componentListSize = weaponList.Count;
for (componentIndex = 0; componentIndex < componentListSize; componentIndex++)
{
// For Progressive, a region index of 0 means Use Progressive Damage
if (weaponList[componentIndex].damageRegionIndex == damageRegionIndex)
{
health = weaponList[componentIndex].Health;
if (health < 0f) { health = healthAmount; }
else { health += healthAmount; }
if (health > weaponList[componentIndex].startingHealth) { health = weaponList[componentIndex].startingHealth; }
// Only set the health value once for a given Weapon
weaponList[componentIndex].Health = health;
}
}
}
}
}
}
/// <summary>
/// Applies damage to the ship due to a collision. The damage is registered as "collision" damage,
/// meaning that if it destroys the ship the ship will be respawned at a previously recorded respawn position.
/// </summary>
/// <param name="collisionInfo"></param>
public void ApplyCollisionDamage (Collision collisionInfo)
{
int hitColliderID = collisionInfo.collider.GetInstanceID();
// Avoid collision with colliders that have been registered with (attached to) this ship
if (!attachedCollisionColliders.Contains(hitColliderID))
{
// Loop through contact points
int numberOfContactPoints = collisionInfo.contactCount;
float damageAtEachPoint = collisionInfo.impulse.magnitude / numberOfContactPoints;
for (int c = 0; c < numberOfContactPoints; c++)
{
//Debug.Log("[DEBUG] " + collisionInfo.collider.name + " hit " + collisionInfo.GetContact(c).thisCollider.name + " T:" + Time.time);
// Apply damage at each contact point
ApplyDamage(damageAtEachPoint, ProjectileModule.DamageType.Default, collisionInfo.GetContact(c).point, true);
}
// Remember that this was collision damage
lastDamageWasCollisionDamage = true;
}
}
/// <summary>
/// Applies a specified amount of damage to the ship at a specified position. The damage is registered as "collision" damage,
/// meaning that if it destroys the ship the ship will be respawned at a previously recorded respawn position.
/// </summary>
/// <param name="damageAmount"></param>
/// <param name="damagePosition"></param>
public void ApplyCollisionDamage(float damageAmount, Vector3 damagePosition)
{
ApplyDamage(damageAmount, ProjectileModule.DamageType.Default, damagePosition, false);
// Remember that this was collision damage
lastDamageWasCollisionDamage = true;
}
/// <summary>
/// Applies a specified amount of damage to the ship at a specified position.
/// </summary>
/// <param name="damageAmount"></param>
/// <param name="damagePosition"></param>
public void ApplyNormalDamage(float damageAmount, ProjectileModule.DamageType damageType, Vector3 damagePosition)
{
ApplyDamage(damageAmount, damageType, damagePosition, false);
// Remember that this was not collision damage
lastDamageWasCollisionDamage = false;
}
/// <summary>
/// Returns the index of the last damage event. When this value changes, a damage event has occurred.
/// </summary>
/// <returns></returns>
public int LastDamageEventIndex() { return lastDamageEventIndex; }
/// <summary>
/// Returns the amount of rumble required due to the last damage event.
/// </summary>
/// <returns></returns>
public float RequiredDamageRumbleAmount() { return damageRumbleAmountRequired; }
/// <summary>
/// Returns the amount of camera shake required due to the last damage event
/// </summary>
/// <returns></returns>
public float RequiredCameraShakeAmount() { return damageCameraShakeAmountRequired; }
#endregion
#region General API Methods
/// <summary>
/// Returns an interpolated velocity in world space (akin to to the interpolated position/rotation on rigidbodies).
/// </summary>
public Vector3 GetInterpolatedWorldVelocity()
{
// Get the time in seconds since the last fixed update
float timeSinceLastFixedUpdate = Time.time - lastFixedUpdateTime;
// Interpolate between the world velocities of the last frame and the previous frame to get an interpolated world velocity
return previousFrameWorldVelocity + (worldVelocity - previousFrameWorldVelocity) * (timeSinceLastFixedUpdate / Time.fixedDeltaTime);
}
/// <summary>
/// Add temporary boost to the ship in a normalised local-space forceDirection
/// which a force of forceAmount Newtons for a period of duration seconds.
/// IMPORTANT: forceDirection must be normalised, otherwise you will get odd results.
/// </summary>
/// <param name="forceDirection"></param>
/// <param name="forceAmount"></param>
/// <param name="duration"></param>
public void AddBoost(Vector3 forceDirection, float forceAmount, float duration)
{
boostDirection = forceDirection;
boostForce = forceAmount;
boostTimer = duration;
}
/// <summary>
/// Immediately stop any boost that has been applied with AddBoost(..).
/// </summary>
public void StopBoost()
{
boostTimer = 0f;
}
#endregion
#region Respawning API Methods
/// <summary>
/// Returns true if the ship has been destroyed.
/// </summary>
public bool Destroyed()
{
if (shipDamageModel == ShipDamageModel.Simple || shipDamageModel == ShipDamageModel.Progressive)
{
return mainDamageRegion.Health <= 0f;
}
else
{
return mainDamageRegion.Health <= 0f;
}
}
/// <summary>
/// Returns the position for the ship to respawn at.
/// </summary>
/// <returns></returns>
public Vector3 GetRespawnPosition()
{
if (respawningMode == RespawningMode.RespawnAtLastPosition)
{
if (lastDamageWasCollisionDamage) { return currentCollisionRespawnPosition; }
else { return currentRespawnPosition; }
}
else if (respawningMode == RespawningMode.RespawnAtOriginalPosition)
{
return currentRespawnPosition;
}
else if (respawningMode == RespawningMode.RespawnAtSpecifiedPosition)
{
return customRespawnPosition;
}
else { return Vector3.zero; }
}
/// <summary>
/// Returns the rotation for the ship to respawn with.
/// </summary>
/// <returns></returns>
public Quaternion GetRespawnRotation()
{
if (respawningMode == RespawningMode.RespawnAtLastPosition)
{
if (lastDamageWasCollisionDamage) { return currentCollisionRespawnRotation; }
else { return currentRespawnRotation; }
}
else if (respawningMode == RespawningMode.RespawnAtOriginalPosition)
{
return currentRespawnRotation;
}
else if (respawningMode == RespawningMode.RespawnAtSpecifiedPosition)
{
return Quaternion.Euler(customRespawnRotation);
}
else { return Quaternion.identity; }
}
#endregion
#region Thruster API Methods
/// <summary>
/// Get the (central) fuel level of the ship. Fuel Level Range 0.0 (empty) to 100.0 (full).
/// </summary>
/// <returns></returns>
public float GetFuelLevel()
{
return centralFuelLevel;
}
/// <summary>
/// Get the fuel level of the Thruster based on the order it appears in the Thrusters tab
/// in the ShipControlModule. Numbers begin at 1.
/// Fuel Level Range 0.0 (empty) to 100.0 (full).
/// </summary>
/// <param name="thrusterNumber"></param>
/// <returns></returns>
public float GetFuelLevel (int thrusterNumber)
{
if (thrusterNumber > 0 && thrusterNumber <= thrusterList.Count)
{
return thrusterList[thrusterNumber - 1].fuelLevel;
}
else { return 0f; }
}
/// <summary>
/// Get the heat level of the Thruster based on the order it appears in the Thrusters tab
/// in the ShipControlModule. Numbers begin at 1.
/// Heat Level Range 0.0 (min) to 100.0 (max).
/// </summary>
/// <param name="thrusterNumber"></param>
/// <returns></returns>
public float GetHeatLevel (int thrusterNumber)
{
if (thrusterNumber > 0 && thrusterNumber <= thrusterList.Count)
{
return thrusterList[thrusterNumber - 1].heatLevel;
}
else { return 0f; }
}
/// <summary>
/// Get the overheating threshold of the Thruster based on the order it appears in the Thrusters tab
/// in the ShipControlModule. Numbers begin at 1.
/// </summary>
/// <param name="thrusterNumber"></param>
/// <returns></returns>
public float GetOverheatingThreshold (int thrusterNumber)
{
if (thrusterNumber > 0 && thrusterNumber <= thrusterList.Count)
{
return thrusterList[thrusterNumber - 1].overHeatThreshold;
}
else { return 0f; }
}
/// <summary>
/// Get the Maximum Thrust of the Thruster based on the order it appears in the Thrusters tab
/// in the ShipControlModule. Numbers begin at 1. Values are returned in kilo Newtons.
/// </summary>
/// <param name="thrusterNumber"></param>
/// <returns></returns>
public float GetMaxThrust (int thrusterNumber)
{
if (thrusterNumber > 0 && thrusterNumber <= thrusterList.Count)
{
return thrusterList[thrusterNumber-1].maxThrust;
}
else { return 0f; }
}
/// <summary>
/// Is the thruster heat level at or above the overheating threshold?
/// Thruster Number is based on the order it appears in the Thrusters tab
/// in the ShipControlModule. Numbers begin at 1.
/// </summary>
/// <param name="thrusterNumber"></param>
/// <returns></returns>
public bool IsThrusterOverheating (int thrusterNumber)
{
if (thrusterNumber > 0 && thrusterNumber <= thrusterList.Count)
{
return thrusterList[thrusterNumber - 1].IsThrusterOverheating();
}
else { return false; }
}
/// <summary>
/// Repair the health of a thruster. Will also set the heat level to 0.
/// Can be useful if a thruster has burnt out after being over heated.
/// Thruster Number is based on the order it appears in the Thrusters tab
/// in the ShipControlModule. Numbers begin at 1.
/// </summary>
/// <param name="thrusterNumber"></param>
public void RepairThruster (int thrusterNumber)
{
if (thrusterNumber > 0 && thrusterNumber <= thrusterList.Count)
{
thrusterList[thrusterNumber - 1].Repair();
}
}
/// <summary>
/// Set the central fuel level for the whole ship. If useCentralFuel is false,
/// use SetFuelLevel (thrusterNumber, new FuelLevel).
/// </summary>
/// <param name="newFuelLevel"></param>
public void SetFuelLevel (float newFuelLevel)
{
// Clamp the fuel level
if (newFuelLevel < 0f) { newFuelLevel = 0f; }
else if (newFuelLevel > 100f) { newFuelLevel = 100f; }
centralFuelLevel = newFuelLevel;
}
/// <summary>
/// Set the fuel level of the Thruster based on the order it appears in the Thrusters tab
/// in the ShipControlModule. Numbers begin at 1.
/// Fuel Level Range 0.0 (empty) to 100.0 (full).
/// </summary>
/// <param name="thrusterNumber"></param>
/// <returns></returns>
public void SetFuelLevel (int thrusterNumber, float newFuelLevel)
{
if (thrusterNumber > 0 && thrusterNumber <= thrusterList.Count)
{
thrusterList[thrusterNumber - 1].SetFuelLevel(newFuelLevel);
}
}
/// <summary>
/// Set the heat level of the Thruster based on the order it appears in the Thrusters tab
/// in the ShipControlModule. Numbers begin at 1.
/// Heat Level Range 0.0 (min) to 100.0 (max).
/// </summary>
/// <param name="thrusterNumber"></param>
/// <returns></returns>
public void SetHeatLevel (int thrusterNumber, float newHeatLevel)
{
if (thrusterNumber > 0 && thrusterNumber <= thrusterList.Count)
{
thrusterList[thrusterNumber - 1].SetHeatLevel(newHeatLevel);
}
}
/// <summary>
/// Set the Maximum Thrust of the Thruster based on the order it appears in the Thruster tab
/// in the ShipControlModule. Numbers begin at 1. Values should be in kilo Newtons
/// </summary>
/// <param name="thrusterNumber"></param>
/// <param name="newMaxThrustkN"></param>
public void SetMaxThrust (int thrusterNumber, int newMaxThrustkN)
{
if (thrusterNumber > 0 && thrusterNumber <= thrusterList.Count)
{
thrusterList[thrusterNumber - 1].maxThrust = newMaxThrustkN * 1000f;
}
}
/// <summary>
/// Use this if you want fine-grained control over max thruster force, otherwise use SetMaxThrust.
/// Set the Maximum Thrust of the Thruster based on the order it appears in the Thruster tab
/// in the ShipControlModule. Numbers begin at 1. Values are in Newtons.
/// </summary>
/// <param name="thrusterNumber"></param>
/// <param name="newMaxThrustNewtons"></param>
public void SetMaxThrustNewtons (int thrusterNumber, float newMaxThrustNewtons)
{
if (thrusterNumber > 0 && thrusterNumber <= thrusterList.Count)
{
thrusterList[thrusterNumber - 1].maxThrust = newMaxThrustNewtons;
}
}
/// <summary>
/// Set all thrusters to the same throttle value.
/// Values are clamped to between 0.0 and 1.0.
/// </summary>
/// <param name="newThrottleValue"></param>
public void SetThrottleAllThrusters (float newThrottleValue)
{
// Clamp values
if (newThrottleValue < 0f) { newThrottleValue = 0f; }
else if (newThrottleValue > 1f) { newThrottleValue = 1f; }
int numThrusters = thrusterList == null ? 0 : thrusterList.Count;
for (int thIdx = 0; thIdx < numThrusters; thIdx++)
{
thrusterList[thIdx].throttle = newThrottleValue;
}
}
/// <summary>
/// Set the throttle for a given thruster. Numbers begin at 1. Values should be between 0.0 and 1.0.
/// </summary>
/// <param name="thrusterNumber"></param>
/// <param name="newThrottleValue"></param>
public void SetThrusterThrottle (int thrusterNumber, float newThrottleValue)
{
if (thrusterNumber > 0 && thrusterNumber <= thrusterList.Count)
{
thrusterList[thrusterNumber - 1].throttle = newThrottleValue < 0f ? 0f : newThrottleValue > 1f ? 1f : newThrottleValue;
}
}
#endregion
#region Weapon API Methods
/// <summary>
/// Deactivate all beam weapons that are currently firing
/// </summary>
public void DeactivateBeams(SSCManager sscManager)
{
int numWeapons = NumberOfWeapons;
for (int weaponIdx = 0; weaponIdx < numWeapons; weaponIdx++)
{
Weapon weapon = weaponList[weaponIdx];
if (weapon != null && (weapon.weaponTypeInt == Weapon.FixedBeamInt || weaponTypeInt == Weapon.TurretBeamInt))
{
int numBeams = weapon.beamItemKeyList == null ? 0 : weapon.beamItemKeyList.Count;
for (int bItemIdx = 0; bItemIdx < numBeams; bItemIdx++)
{
if (weapon.beamItemKeyList[bItemIdx].beamSequenceNumber > 0)
{
sscManager.DeactivateBeam(weapon.beamItemKeyList[bItemIdx]);
}
weapon.beamItemKeyList[bItemIdx] = new SSCBeamItemKey(-1, -1, 0);
}
}
}
}
/// <summary>
/// Get the zero-based index of a weapon on the ship given the weapon name. Returns -1 if not found.
/// Use this sparingly as it will incur garabage. Always declare the parameter as a static readonly variable.
/// Usage:
/// private static readonly string WPNturret1Name = "Turret 1";
/// ..
/// int wpIdx = GetWeaponIndexByName(WPNturret1Name);
/// </summary>
/// <param name="weaponName"></param>
/// <returns></returns>
public int GetWeaponIndexByName(string weaponName)
{
if (weaponList != null) { return weaponList.FindIndex(wp => wp.name == weaponName); }
else { return -1; }
}
/// <summary>
/// Get the weapon on the ship from a zero-based index in the list of weapons.
/// This will be 1 less than the number shown next to the weapon on the Combat tab.
/// It validates the weaponIdx so if possible, don't call this every frame.
/// </summary>
/// <param name="weaponIdx"></param>
/// <returns></returns>
public Weapon GetWeaponByIndex(int weaponIdx)
{
if (weaponIdx >= 0 && weaponIdx < (weaponList == null ? 0 : weaponList.Count))
{
return weaponList[weaponIdx];
}
else { return null; }
}
/// <summary>
/// Get the heat level of the Weapon with the zero-based index in list of weapons.
/// Heat Level Range 0.0 (min) to 100.0 (max).
/// </summary>
/// <param name="weaponIdx"></param>
/// <returns></returns>
public float GetWeaponHeatLevel (int weaponIdx, float newHeatLevel)
{
if (weaponIdx >= 0 && weaponIdx < (weaponList == null ? 0 : weaponList.Count))
{
return weaponList[weaponIdx].heatLevel;
}
else { return 0f; }
}
/// <summary>
/// Get the index in the weaponList of next weapon that has AutoTargetingEnabled.
/// If no match is found, return -1. startIdx is the zero-based index in the
/// weaponList to begin the search.
/// </summary>
/// <param name="startIdx"></param>
/// <returns></returns>
public int GetNextAutoTargetingWeaponIndex(int startIdx)
{
int foundWeaponIdx = -1;
Weapon _tempWeapon = null;
int numWeapons = weaponList == null ? 0 : weaponList.Count;
if (startIdx >= 0 && startIdx < numWeapons)
{
// Use a for-loop rather than list.Find to avoid GC
for (int weaponIdx = startIdx; weaponIdx < numWeapons; weaponIdx++)
{
_tempWeapon = weaponList[weaponIdx];
if (_tempWeapon != null && _tempWeapon.isAutoTargetingEnabled)
{
foundWeaponIdx = weaponIdx;
break;
}
}
}
return foundWeaponIdx;
}
/// <summary>
/// Clears all targeting information for the weapon. This should be called if you do not
/// know if the target is a ship or a gameobject.
/// WARNING: For the sake of performance, does not validate weaponIdx.
/// </summary>
/// <param name="weaponIdx">zero-based index in list of weapons</param>
public void ClearWeaponTarget(int weaponIdx)
{
if (weaponIdx >= 0) { weaponList[weaponIdx].ClearTarget(); }
}
/// <summary>
/// Has the weapon with the zero-based index in list of weapons got a target
/// assigned to it? The target could be a GameObject or a Ship.
/// WARNING: For the sake of performance, does not validate weaponIdx.
/// </summary>
/// <param name="weaponIdx"></param>
/// <returns></returns>
public bool HasWeaponTarget(int weaponIdx)
{
if (weaponIdx >= 0) { return weaponList[weaponIdx].target != null; }
else { return false; }
}
/// <summary>
/// Set the heat level of the Weapon with the zero-based index in list of weapons.
/// Heat Level Range 0.0 (min) to 100.0 (max).
/// </summary>
/// <param name="weaponIdx"></param>
/// <returns></returns>
public void SetWeaponHeatLevel (int weaponIdx, float newHeatLevel)
{
if (weaponIdx >= 0 && weaponIdx < (weaponList == null ? 0 : weaponList.Count))
{
weaponList[weaponIdx].SetHeatLevel(newHeatLevel);
}
}
/// <summary>
/// Sets the gameobject that the weapon will attempt to aim at. Currently only applies
/// to Weapon.WeaponType.TurretProjectile and FixedProjectile weapons with guided projectiles.
/// However, for the sake of performance, this method does not do any WeaponType validation.
/// WARNING: This method will generate garbage. Where possible call
/// SetWeaponTarget(int weaponIdx, GameObject target). If only the name is known,
/// first call GetWeaponIndexByName(string weaponName) once in your Awake() routine.
/// </summary>
/// <param name="weaponName"></param>
/// <param name="target"></param>
public void SetWeaponTarget(string weaponName, GameObject target)
{
int wpIdx = GetWeaponIndexByName(weaponName);
if (wpIdx >= 0)
{
// It is quicker not to check the weapon type and just set the target
// Call SetTarget so it is configured correctly rather than setting the public variable
weaponList[wpIdx].SetTarget(target);
}
}
/// <summary>
/// Sets the gameobject that the weapon will attempt to aim at. Currently only applies
/// to Weapon.WeaponType.TurretProjectile and FixedProjectile weapons with guided projectiles.
/// However, for the sake of performance, this method does not do any WeaponType validation.
/// WARNING: For the sake of performance, does not validate weaponIdx.
/// </summary>
/// <param name="weaponIdx">zero-based index in list of weapons</param>
/// <param name="target"></param>
public void SetWeaponTarget(int weaponIdx, GameObject target)
{
// Currently don't check weapon type or number of weapons as this would incur overhead.
if (weaponIdx >= 0)
{
// Call SetTarget so it is configured correctly rather than setting the public variable
weaponList[weaponIdx].SetTarget(target);
}
}
/// <summary>
/// Sets the ship that the weapon will attempt to aim at. Currently only applies
/// to Weapon.WeaponType.TurretProjectile and FixedProjectile weapons with guided projectiles.
/// However, for the sake of performance, this method does not do any WeaponType validation.
/// WARNING: For the sake of performance, does not validate weaponIdx.
/// </summary>
/// <param name="weaponIdx">zero-based index in list of weapons</param>
/// <param name="targetShipControlModule"></param>
public void SetWeaponTargetShip(int weaponIdx, ShipControlModule targetShipControlModule)
{
// Currently don't check weapon type or number of weapons as this would incur overhead.
if (weaponIdx >= 0)
{
// Call SetTargetShip so it is configured correctly rather than setting the public variable
weaponList[weaponIdx].SetTargetShip(targetShipControlModule);
}
}
/// <summary>
/// Sets the ship's damage region that the weapon will attempt to aim at. Currently only applies
/// to Weapon.WeaponType.TurretProjectile and FixedProjectile weapons with guided projectiles.
/// However, for the sake of performance, this method does not do any WeaponType validation.
/// WARNING: For the sake of performance, does not validate weaponIdx.
/// </summary>
/// <param name="weaponIdx"></param>
/// <param name="targetShipControlModule"></param>
/// <param name="damageRegion"></param>
public void SetWeaponTargetShipDamageRegion (int weaponIdx, ShipControlModule targetShipControlModule, DamageRegion damageRegion)
{
// Currently don't check weapon type or number of weapons as this would incur overhead.
if (weaponIdx >= 0)
{
// Call SetTargetShipDamageRegion so it is configured correctly rather than setting the public variable
weaponList[weaponIdx].SetTargetShipDamageRegion(targetShipControlModule, damageRegion);
}
}
/// <summary>
/// Performs a once-off change to the direction the weapon will fire based on a
/// "target" position in world-space. The weapon will NOT stay locked onto this
/// position.
/// NOTE: Should NOT be used for Turrets. Use SetWeaponTarget(..) instead.
/// WARNING: For the sake of performance, does not validate weaponIdx.
/// </summary>
/// <param name="weaponIdx">zero-based position in the list of weapons</param>
/// <param name="aimAtWorldSpacePosition"></param>
public void SetWeaponFireDirection(int weaponIdx, Vector3 aimAtWorldSpacePosition)
{
// Currently don't check weapon type or number of weapons as this would incur overhead.
if (weaponIdx >= 0)
{
Weapon weapon = weaponList[weaponIdx];
if (weapon != null)
{
// Get base weapon world position (not accounting for relative fire position)
weaponWorldBasePosition = (trfmRight * weapon.relativePosition.x) +
(trfmUp * weapon.relativePosition.y) +
(trfmFwd * weapon.relativePosition.z) +
trfmPos;
// Convert ws fire direction into local ship space
weapon.fireDirection = trfmInvRot * (aimAtWorldSpacePosition - weaponWorldBasePosition);
weapon.Initialise(trfmInvRot);
}
}
}
/// <summary>
/// Returns whether a weapon has line of sight to the weapon's specified target (i.e. weapon.target).
/// If directToTarget is set to true, will raycast directly from the weapon to the target.
/// If directToTarget is set to false, will raycast in the direction the weapon is facing.
/// This method will return true if the raycast hits:
/// a) The weapon's specified target,
/// b) An enemy ship (distinguished by faction ID) - even if it is not the target and anyEnemy is true,
/// c) An object that isn't the target (if obstaclesBlockLineOfSight is set to false),
/// d) Nothing.
/// This method will return false if the raycast hits:
/// a) A friendly ship (distinguished by faction ID),
/// b) An object that isn't the target (if obstaclesBlockLineOfSight is set to true).
/// c) An enemy ship that is not the target when anyEnemy is false
/// </summary>
/// <param name="weapon"></param>
/// <param name="directToTarget"></param>
/// <returns></returns>
public bool WeaponHasLineOfSight (Weapon weapon, bool directToTarget = false, bool obstaclesBlockLineOfSight = true, bool anyEnemy = true)
{
return WeaponHasLineOfSight(weapon, weapon.target, directToTarget, obstaclesBlockLineOfSight, anyEnemy);
}
/// <summary>
/// Returns whether a weapon has line of sight to a target.
/// If directToTarget is set to true, will raycast directly from the weapon to the target.
/// If directToTarget is set to false, will raycast in the direction the weapon is facing.
/// This method will return true if the raycast hits:
/// a) The target,
/// b) An enemy ship (distingushed by faction ID) - even if it is not the target and anyEnemy is true,
/// c) An object that isn't the target (if obstaclesBlockLineOfSight is set to false),
/// d) Nothing.
/// This method will return false if the raycast hits:
/// a) A friendly ship (distinguished by faction ID),
/// b) An object that isn't the target (if obstaclesBlockLineOfSight is set to true).
/// c) An enemy ship that is not the target when anyEnemy is false
/// </summary>
/// <param name="weapon"></param>
/// <param name="target"></param>
/// <param name="directToTarget"></param>
/// <returns></returns>
public bool WeaponHasLineOfSight(Weapon weapon, GameObject target, bool directToTarget = false, bool obstaclesBlockLineOfSight = true, bool anyEnemy = true)
{
// Update the line-of-sight property
weapon.UpdateLineOfSight(target, trfmPos, trfmRight, trfmUp, trfmFwd, trfmInvRot, factionId,
false, directToTarget, obstaclesBlockLineOfSight, anyEnemy);
// Return the updated property
return weapon.HasLineOfSight;
}
#endregion
#endregion
}
}