using System.Collections.Generic;
using UnityEngine;
using System.Collections;
#if UNITY_EDITOR
using UnityEditor;
#endif
// Sci-Fi Ship Controller. Copyright (c) 2018-2023 SCSM Pty Ltd. All rights reserved.
namespace SciFiShipController
{
[AddComponentMenu("Sci-Fi Ship Controller/Ship Components/Ship Control Module")]
[HelpURL("https://scsmmedia.com/ssc-documentation")]
[RequireComponent(typeof(Rigidbody))]
[DisallowMultipleComponent]
public class ShipControlModule : MonoBehaviour
{
#region Public Variables and Properties
[HideInInspector] public bool allowRepaint = false;
/// <summary>
/// The class in which the majority of ship data is stored in. Typically use this to access/modify data relating to a ship.
/// You should check IsInitialised before referencing the shipInstance.
/// </summary>
public Ship shipInstance;
/// <summary>
/// [INTERNAL USE ONLY]
/// </summary>
public GameObject[] thrusterEffectObjects = new GameObject[1];
// Remember which tabs etc were shown
[HideInInspector] public int selectedTabInt = 0;
/// <summary>
/// [READONLY] Has the ship been initialised?
/// </summary>
public bool IsInitialised { get { return isInitialised; } }
/// <summary>
/// [READONLY] Session-only transform InstanceID.
/// </summary>
public int GetShipId { get { return isInitialised ? shipInstance.shipId : transform.GetInstanceID(); } }
/// <summary>
/// Attempt to get or set gravitational acceleration (must be initialised)
/// </summary>
public float GravitationalAcceleration { get { return isInitialised ? shipInstance.gravitationalAcceleration : 0f; } set { if (isInitialised) { shipInstance.gravitationalAcceleration = value; } } }
/// <summary>
/// Attempt to get or set the direction gravity is acting the ship (must be initialised)
/// </summary>
public Vector3 GravityDirection { get { return isInitialised ? shipInstance.gravityDirection : Vector3.zero; } set { if (isInitialised) { shipInstance.gravityDirection = value; } } }
/// <summary>
/// [READONLY] The rigidbody of the ship.
/// </summary>
public Rigidbody ShipRigidbody { get { return rBody; } }
/// <summary>
/// Are the thruster systems online or in the process of coming online?
/// At runtime call StartupThrusterSystems() or ShutdownThrusterSystems().
/// </summary>
public bool IsThrusterSystemsStarted { get { return isInitialised ? shipInstance.isThrusterSystemsStarted : false; } }
/// <summary>
/// [READONLY] Is the ship currently being respawned?
/// The ship will be disabled during the respawn time.
/// </summary>
public bool IsRespawning { get { return isRespawning; } }
/// <summary>
/// [READONLY] Has respawning been paused? If so, this ship cannot respawn
/// until ResumeRespawning() has been called. See also PauseRespawning().
/// </summary>
public bool IsRespawningPaused { get { return isRespawingPaused; } }
/// <summary>
/// [READONLY] Is this ship visible to the radar?
/// </summary>
public bool IsVisbleToRadar { get { return isInitialised && shipInstance != null && shipInstance.isRadarEnabled && sscRadar != null && sscRadar.GetVisibility(shipInstance.radarItemIndex); } }
/// <summary>
/// [READONLY] The number of weapons on this ship. Will always return 0 if ship has not been initialised.
/// See also ship.NumberOfWeapons.
/// </summary>
public int NumberOfWeapons { get { return isInitialised ? (shipInstance.weaponList == null ? 0 : shipInstance.weaponList.Count) : 0; } }
/// <summary>
/// [READONLY] The number of times the ship has been respawned. This is incremented
/// when the ship is respawned - not when it is destroyed.
/// </summary>
public int NumberOfRespawns { get { return respawnCount; } }
/// <summary>
/// [INTERNAL USE ONLY]
/// </summary>
public string editorSearchThrusterFilter;
#if UNITY_EDITOR
public string ThrusterSystemsStatus { get { return isInitialised ? (shipInstance.isThrusterSystemsStarted ? (shipInstance.thrusterSystemShutdownTimer > 0f ? "shutting down" : (shipInstance.thrusterSystemStartupTimer > 0f ? "starting up" : "online") ) : "offline") : "--"; } }
#endif
#endregion
#region Private Variables
private bool isInitialised = false;
private SSCManager sscManager;
private SSCRadar sscRadar;
private ThrusterEffects[] thrusterEffects;
/// <summary>
/// Used internally to reset PID Controllers on AI ships
/// when ship velocity is set to 0.
/// </summary>
private ShipAIInputModule shipAIInputModule;
private bool isShipAIInputModuleAttached = false;
private ShipDocking shipDocking;
private bool isShipDockingAttached = false;
private Rigidbody rBody;
private List<Renderer> activeRenderersList;
private List<AudioSource> audioSourcesList;
/// <summary>
/// This prevents the activeRenderersList being updated while the ship
/// is disabled
/// </summary>
private bool isShipVisibilityDisabled = false;
private int componentIndex;
private int arrayLength;
private Thruster thruster;
private bool shipIsEnabled = true;
/// <summary>
/// This is a subset of shipIsEnabled. Current applies to:
/// 1) Physics
/// 2) Thruster Effects
/// 3) User or AI Input
/// 4) Sound FX (audio)
/// </summary>
[SerializeField]
private bool isMovementEnabled = true;
private int lastDamageEventIndex = 0;
private float damageRumbleTimer = -1f;
#region Input Variables
private Vector3 pilotForceInput = Vector3.zero;
// Make non-serialized internal so is visible to ShipCameraModule
[System.NonSerialized] internal Vector3 pilotMomentInput = Vector3.zero;
// TODO: There could be a problem with ship fire input
// If framerate drops below 50 FPS, fixedupdate will be called more often than update
// Therefore it would be possible for fixedupate to be called twice or more between update calls
// So if fire can be held is false, fire could still be true for multiple frames for a single fire call
// However, maybe this won't be a problem if reload time is kept high enough?
private bool pilotPrimaryFireInput = false;
private bool pilotSecondaryFireInput = false;
private bool pilotDockInput = false;
#endregion
#region FixedUpdate Variables
private Vector3 localResultantForce;
private Vector3 localResultantMoment;
private bool isRespawning = false;
private bool isRespawingPaused = false;
private int respawnCount = 0;
private float respawnTimer = 0f;
private float stuckTimer = 0f;
#endregion
#endregion
#region Public Static Version Properties
public static string SSCVersion { get { return "1.3.7"; } }
public static string SSCBetaVersion { get { return ""; } }
#endregion
#region Public Delegates
public delegate void CallbackOnCollision(ShipControlModule shipControlModule, Collision collision);
public delegate void CallbackOnDestroy(Ship ship);
public delegate void CallbackOnRespawn(ShipControlModule shipControlModule, ShipAIInputModule shipAIInputModule);
public delegate void CallbackOnHit(CallbackOnShipHitParameters callbackOnShipHitParameters);
public delegate void CallbackOnStuck(ShipControlModule shipControlModule);
public delegate void CallbackOnRumble(float rumbleAmount);
/// <summary>
/// The name of the custom method that is called immediately after a collision.
/// Your method must take 2 parameters (ShipControlModule and Collision).
/// This should be a lightweight method to avoid performance issues.
/// </summary>
[System.NonSerialized] public CallbackOnCollision callbackOnCollision = null;
/// <summary>
/// The name of the custom method that is called immediately
/// before the ship is destroyed. Your method must take 1
/// parameter of class Ship. This should be a lightweight
/// method to avoid performance issues. It could be used to update
/// a score or remove a ship from a squadron.
/// </summary>
[System.NonSerialized] public CallbackOnDestroy callbackOnDestroy = null;
/// <summary>
/// The name of the custom method that is called immediately
/// after the ship is respawned. Your method must take 2 parameters: ShipControlModule
/// and ShipAIInputModule. The first is never null but there may be no AI module
/// attached to this ship. This should be a lightweight method to avoid
/// performance issues.
/// </summary>
[System.NonSerialized] public CallbackOnRespawn callbackOnRespawn = null;
/// <summary>
/// The name of the custom method that is called immediately
/// after the ship is hit by a projectile or beam. Your method must take 1
/// parameter of type CallbackOnShipHitParameters. This should be
/// a lightweight method to avoid performance issues. It could be used to
/// take evasive action while being pursued by an enemy ship. It could
/// also be used to detect friendly fire.
/// </summary>
[System.NonSerialized] public CallbackOnHit callbackOnHit = null;
/// <summary>
/// The name of the custom method that is called immediately after
/// a ship is detected as stuck. To avoid performance issues, action
/// should be taken otherwise your method may be called each subsequent
/// frame. See also ship.stuckTime and ship.stuckSpeedThreshold.
/// </summary>
[System.NonSerialized] public CallbackOnStuck callbackOnStuck = null;
/// <summary>
/// Generally reserved for internal use by the PlayerInputModule. If the human
/// player ship does not have the PlayerInputModule component attached, you can
/// create a lightweight custom method and assign it at runtime so that it is
/// called whenever device rumble or force feedback is required.
/// </summary>
[System.NonSerialized] public CallbackOnRumble callbackOnRumble = null;
#endregion
#region Private Initialise Methods
// Use this for initialization
void Awake()
{
if (shipInstance.initialiseOnAwake)
{
InitialiseShip();
}
}
#endregion
#region Update Methods
void Update()
{
if (isInitialised)
{
if (isRespawning)
{
#region Respawning
// If we are currently respawning, count down respawn timer
respawnTimer -= isRespawingPaused ? 0f : Time.deltaTime;
// Once respawn time reaches zero, respawn the ship
if (respawnTimer <= 0f)
{
// We are now not in the process of respawning
isRespawning = false;
respawnCount++;
// Reset the health of the ship
shipInstance.ResetHealth();
shipInstance.ResetThrusterSystems();
if (shipInstance.respawningMode == Ship.RespawningMode.RespawnOnPath)
{
RespawnOnPath(shipInstance.respawningPathGUIDHash, true, false);
}
else
{
// Set ship position and rotation
transform.SetPositionAndRotation(shipInstance.GetRespawnPosition(), shipInstance.GetRespawnRotation());
// Re-enable the ship and make it visible again
EnableOrDisableShip(true, true, false);
}
// Re-initialise ground match variables since this will also reset PID controller
shipInstance.ReinitialiseGroundMatchVariables();
// Set ship velocity
rBody.velocity = transform.TransformDirection(shipInstance.respawnVelocity);
rBody.angularVelocity = Vector3.zero;
// If there is an AI component attached, reset the PID controllers
// TODO: Test whether this is effective for when an AI respawns with a given velocity
if (isShipAIInputModuleAttached && shipAIInputModule != null)
{
if (shipAIInputModule.IsInitialised) { shipAIInputModule.ResetPIDControllers(); }
else { shipAIInputModule.Initialise(); }
}
if (callbackOnRespawn != null) { callbackOnRespawn(this, shipAIInputModule); }
}
#endregion
}
else
{
// Only apply input, calculate movement, update effects or process damage if the ship is enabled
if (shipIsEnabled)
{
// Weapons can only fire, respawning after a collision, when movement is enabled.
#region Pass input / apply combat output
if (isMovementEnabled || shipInstance.useWeaponsWhenMovementDisabled)
{
// Pass position and movement data to the ship
shipInstance.UpdatePositionAndMovementData(transform, rBody);
// Pass pilot weapons input to the ship
shipInstance.pilotPrimaryFireInput = pilotPrimaryFireInput;
shipInstance.pilotSecondaryFireInput = pilotSecondaryFireInput;
// Update weapons and damage data
shipInstance.UpdateWeaponsAndDamage(sscManager);
}
#endregion
// Thrusters only work when movement is enabled
// OR when isThrusterFXStationary is true.
#region Visual/Audial Effects
// Behaviour change for 1.3.7 Beta 2a
if (shipInstance.isThrusterSystemsStarted && (isMovementEnabled || shipInstance.isThrusterFXStationary))
{
UpdateThrusterFX();
}
#endregion
#region Localised Damage Region Destruction, shield recharge, or Radar Update
if (shipInstance.shipDamageModel == Ship.ShipDamageModel.Localised &&
shipInstance.numLocalisedDamageRegions > 0 && sscManager != null)
{
// Loop through localised damage regions
DamageRegion damageRegion;
for (int d = 0; d < shipInstance.numLocalisedDamageRegions; d++)
{
damageRegion = shipInstance.localisedDamageRegionList[d];
#region Effects Object for damage region
// If a damage region has been "destroyed" but no effects object has been instantiated...
if (damageRegion.Health <= 0f && !damageRegion.isDestructionEffectsObjectInstantiated)
{
// If there is an effects object for this damage region, instantiate it.
if (damageRegion.effectsObjectPrefabID > 0)
{
InstantiateEffectsObjectParameters ieParms = new InstantiateEffectsObjectParameters
{
effectsObjectPrefabID = damageRegion.effectsObjectPrefabID,
position = transform.TransformPoint(damageRegion.relativePosition),
rotation = shipInstance.TransformRotation
};
// Keep track of the EffectsModule instance that was instantiated for this region
if (sscManager.InstantiateEffectsObject(ref ieParms) != null)
{
damageRegion.destructionEffectItemKey = new SSCEffectItemKey(damageRegion.effectsObjectPrefabID, ieParms.effectsObjectPoolListIndex, ieParms.effectsObjectSequenceNumber);
}
}
// Then remember that we have instantiated an effects object, so we don't do it again
damageRegion.isDestructionEffectsObjectInstantiated = true;
}
// Check if the effects object should move with the ship
else if (damageRegion.isMoveDestructionEffectsObject && damageRegion.destructionEffectItemKey.effectsObjectSequenceNumber > 0)
{
// Find the effects object, validate it is the correct one (it hasn't been despawned) and update position/rotation
if (!sscManager.MoveEffectsObject(damageRegion.destructionEffectItemKey, transform.TransformPoint(damageRegion.relativePosition), shipInstance.TransformRotation, true))
{
// The effect may have been despawned
// Once the effect has finished, it will not be respawned for this damage region
damageRegion.destructionEffectItemKey = new SSCEffectItemKey(-1, -1, 0);
}
}
#endregion
if (damageRegion.Health > 0f)
{
#region Damage Region Radar Update
if (shipInstance.isRadarEnabled && damageRegion.isRadarEnabled && damageRegion.radarItemIndex >= 0)
{
// Update fields that may change at any time
damageRegion.sscRadarPacket.isVisibleToRadar = true;
damageRegion.sscRadarPacket.position = shipInstance.GetDamageRegionWSPosition(damageRegion);
damageRegion.sscRadarPacket.velocity = shipInstance.WorldVelocity;
damageRegion.sscRadarPacket.factionId = shipInstance.factionId;
damageRegion.sscRadarPacket.squadronId = shipInstance.squadronId;
// Use the internal radarItemIndex rather than RadarId to avoid the property lookup
sscRadar.UpdateItem(damageRegion.radarItemIndex, damageRegion.sscRadarPacket);
}
#endregion
#region Local Damage Region Shield Recharge
damageRegion.CheckShieldRecharge();
#endregion
}
// Only destroy the damage region once
else if (!damageRegion.isDestroyed)
{
#region Damage Region Destruct
DestructDamageRegion(damageRegion, false);
if (damageRegion.regionChildTransform != null)
{
damageRegion.regionChildTransform.gameObject.SetActive(false);
// Return any weapon muzzle FX to the pool
DestroyFX(damageRegion.regionChildTransform);
}
// The damage region destroy action has occurred
damageRegion.isDestroyed = true;
if (damageRegion.isRadarEnabled) { DisableRadar(damageRegion); }
#endregion
}
}
}
#endregion
#region Check if ship is stuck
if (isMovementEnabled && IsShipStuck())
{
if (shipInstance.stuckAction == Ship.StuckAction.InvokeCallback)
{
if (callbackOnStuck != null) { callbackOnStuck(this); }
}
else if (shipInstance.stuckAction == Ship.StuckAction.RespawnOnPath)
{
// Stop camera shake if it is currently happening
if (shipInstance.callbackOnCameraShake != null) { shipInstance.callbackOnCameraShake(0f); }
RespawnOnPath(shipInstance.stuckActionPathGUIDHash, false, true);
}
else if (shipInstance.stuckAction == Ship.StuckAction.SameAsRespawningMode)
{
if (shipInstance.respawningMode != Ship.RespawningMode.DontRespawn)
{
// We are now in the process of respawning
isRespawning = true;
// Set the respawn timer
respawnTimer = shipInstance.respawnTime;
// Stop camera shake if it is currently happening
if (shipInstance.callbackOnCameraShake != null) { shipInstance.callbackOnCameraShake(0f); }
// Now we want to "despawn" this ship
// So we simply disable all visual and physics components
// Disable the ship and make it invisible
EnableOrDisableShip(false, true, false);
}
}
}
#endregion
#region Damage - Rumble and Camera Shake
if (isMovementEnabled && !shipInstance.Destroyed())
{
// Check if the last damage event index has changed
int thisDamageEventIndex = shipInstance.LastDamageEventIndex();
if (lastDamageEventIndex != thisDamageEventIndex)
{
// If the last damage event index has changed, there has been a damage event
lastDamageEventIndex = thisDamageEventIndex;
if (shipInstance.applyControllerRumble)
{
// Apply rumble
if (callbackOnRumble != null) { callbackOnRumble(shipInstance.RequiredDamageRumbleAmount()); }
// Set the rumble timer
damageRumbleTimer = 0.5f;
}
if (shipInstance.callbackOnCameraShake != null) { shipInstance.callbackOnCameraShake(shipInstance.RequiredCameraShakeAmount()); }
}
// NOTE: CameraShake is turned off by a timer in ShipCameraModule or by calling StopCameraShake(..)
else if (shipInstance.applyControllerRumble)
{
// Count down the rumble timer
if (damageRumbleTimer > 0f)
{
damageRumbleTimer -= Time.deltaTime;
}
// If the timer reaches zero, disable rumble
if (damageRumbleTimer < 0f)
{
if (callbackOnRumble != null) { callbackOnRumble(0f); }
}
}
}
#endregion
#region Docking
// If ship is still enabled, perform dock action
if (pilotDockInput && shipIsEnabled && isShipDockingAttached && shipDocking.IsInitialised)
{
// Currently only supports Docked and Undocked for player ships
if (shipDocking.GetStateInt() == ShipDocking.dockedInt)
{
shipDocking.SetState(ShipDocking.DockingState.NotDocked);
}
else
{
shipDocking.SetState(ShipDocking.DockingState.Docked);
}
}
#endregion
}
#region Ship Destruction OR Ship radar update and Thruster Systems startup/shutdown
// Check if the ship has been destroyed
if (shipInstance.Destroyed())
{
// Stop camera shake if it is currently happening
if (shipInstance.callbackOnCameraShake != null) { shipInstance.callbackOnCameraShake(0f); }
DestroyFX(transform);
if (callbackOnDestroy != null) { callbackOnDestroy(this.shipInstance); }
// Check if the ship should be respawned
if (shipInstance.respawningMode != Ship.RespawningMode.DontRespawn)
{
// We are now in the process of respawning
isRespawning = true;
// Set the respawn timer
respawnTimer = shipInstance.respawnTime;
// Now we want to "despawn" this ship
// So we simply disable all visual and physics components
// Disable the ship and make it invisible
EnableOrDisableShip(false, true, false);
if (sscManager != null)
{
#region Instantiate the ship destruction effects prefab
if (shipInstance.mainDamageRegion.destructionEffectsObject != null)
{
InstantiateEffectsObjectParameters ieParms = new InstantiateEffectsObjectParameters
{
effectsObjectPrefabID = shipInstance.mainDamageRegion.effectsObjectPrefabID,
position = transform.position,
rotation = transform.rotation
};
sscManager.InstantiateEffectsObject(ref ieParms);
}
#endregion
DestructDamageRegion(shipInstance.mainDamageRegion, true);
}
// End the rumble timer
damageRumbleTimer = -1f;
}
else
{
shipInstance.DeactivateBeams(sscManager);
// If the ship is using radar, remove it from radar before the ship gameobject
// is destroyed. Also remove any Localised Damage Regions from radar.
if (shipInstance.isRadarEnabled && shipInstance.radarItemIndex >= 0)
{
DisableRadar();
//sscRadar.DisableRadar(shipInstance.radarItemIndex);
}
if (sscManager != null)
{
#region Instantiate the ship destruction effects prefab
if (shipInstance.mainDamageRegion.destructionEffectsObject != null)
{
InstantiateEffectsObjectParameters ieParms = new InstantiateEffectsObjectParameters
{
effectsObjectPrefabID = shipInstance.mainDamageRegion.effectsObjectPrefabID,
position = transform.position,
rotation = transform.rotation
};
sscManager.InstantiateEffectsObject(ref ieParms);
}
#endregion
DestructDamageRegion(shipInstance.mainDamageRegion, true);
}
// Destroy this ship
// Prevent the shipInstance referencing the ShipControlModule transform.
if (isInitialised) { shipInstance.shipTransform = null; }
Destroy(gameObject);
// Need to also destroy the ship class instance
if (shipInstance != null) { isInitialised = false; shipInstance = null; }
}
}
else if (shipIsEnabled)
{
if (shipInstance.isRadarEnabled)
{
// Update fields that may change at any time
shipInstance.sscRadarPacket.isVisibleToRadar = true;
shipInstance.sscRadarPacket.position = shipInstance.TransformPosition;
shipInstance.sscRadarPacket.velocity = shipInstance.WorldVelocity;
shipInstance.sscRadarPacket.factionId = shipInstance.factionId;
shipInstance.sscRadarPacket.squadronId = shipInstance.squadronId;
// Use the internal radarItemIndex rather than RadarId to avoid the property lookup
sscRadar.UpdateItem(shipInstance.radarItemIndex, shipInstance.sscRadarPacket);
}
bool hasStarted, hasShutdown;
if (shipInstance.CheckThrusterSystems(Time.deltaTime, out hasStarted, out hasShutdown))
{
if (hasShutdown)
{
StopThrusterEffects();
}
}
shipInstance.mainDamageRegion.CheckShieldRecharge();
}
#endregion
}
}
}
// FixedUpdate is called once per physics update (typically about 50 times per second)
void FixedUpdate()
{
if (isInitialised)
{
if (!isRespawning)
{
//float calcStartTime = Time.realtimeSinceStartup;
// When shipIsEnabled is false, isMovementEnabled is also false,
// though the opposite may not be true.
if (shipIsEnabled && isMovementEnabled)
{
#region Pass input / apply movement output
// Pass position and movement data to the ship
shipInstance.UpdatePositionAndMovementData(transform, rBody);
// Pass pilot movement input to the ship
shipInstance.pilotForceInput = pilotForceInput;
shipInstance.pilotMomentInput = pilotMomentInput;
// Calculate the local resultant force and moment
shipInstance.CalculateForceAndMoment(ref localResultantForce, ref localResultantMoment);
// Apply the local resultant force and moment to the rigidbody
rBody.AddRelativeForce(localResultantForce);
rBody.AddRelativeTorque(localResultantMoment);
#endregion
}
//float calcEndTime = Time.realtimeSinceStartup;
//Debug.Log("| Total: " + ((calcEndTime - calcStartTime) * 1000f).ToString("0.0000") + " ms |");
}
}
}
#endregion
#region Private Methods
/// <summary>
/// Enables or disables the ship (depending on the value of isEnabled). If updateVisibility is set to true,
/// changes whether the ship is visible. If resetVelocity is set to true, resets the velocity of the ship to zero.
/// Movement is not enabled if the ship is docked, although collision detection is updated.
/// </summary>
/// <param name="isEnabled"></param>
/// <param name="updateVisibility"></param>
/// <param name="resetVelocity"></param>
private void EnableOrDisableShip(bool isEnabled, bool updateVisibility, bool resetVelocity)
{
// This does not prove the ship is docked, but the ship thinks it is docked. For absolute proof, we would
// need to check the ShipDockingStation's docking points (which is prob too expensive here).
bool isDocked = isShipDockingAttached && shipDocking.IsInitialised && shipDocking.GetStateInt() == ShipDocking.dockedInt;
if (isDocked && isEnabled)
{
ShipRigidbody.detectCollisions = shipDocking.detectCollisionsWhenDocked;
}
else
{
EnableOrDisableShipPhysics(isEnabled, resetVelocity);
// Pause/resume thruster effects
PauseOrResumeThrusters(isEnabled);
}
#region Update Visuals
if (updateVisibility)
{
if (isEnabled)
{
// Re-enable previously active renderers
arrayLength = activeRenderersList.Count;
for (componentIndex = 0; componentIndex < arrayLength; componentIndex++)
{
activeRenderersList[componentIndex].enabled = true;
}
isShipVisibilityDisabled = false;
}
else
{
shipInstance.DeactivateBeams(sscManager);
// We are disabling the ship - so we disable all visual and audial components
#region Find and Disable Renderers
if (!isShipVisibilityDisabled)
{
// Prevent the list being cleared when the ship is already disabled
isShipVisibilityDisabled = true;
// Get all the renderers in the ship and store them in a list
// Use a pre-defined reusable list. If respawning happens multiple
// times there will be a lot of GC which will hurt performance.
GetComponentsInChildren(activeRenderersList);
// Loop through the renderers
arrayLength = activeRenderersList.Count;
componentIndex = 0;
while (componentIndex < arrayLength)
{
if (!activeRenderersList[componentIndex].enabled)
{
// If the renderer is currently disabled, remove it from the list
// (We don't want to enable it when we respawn)
activeRenderersList.RemoveAt(componentIndex);
arrayLength--;
}
else
{
// If the renderer is currently enabled, disable it (and leave it in the list)
activeRenderersList[componentIndex].enabled = false;
componentIndex++;
}
}
}
#endregion
StopAudioSources();
}
}
#endregion
#region Update Rumble
if (!isEnabled && callbackOnRumble != null) { callbackOnRumble(0f); }
#endregion
#region Update Radar
if (shipInstance.isRadarEnabled)
{
sscRadar.SetVisibility(shipInstance.RadarId, isEnabled);
// If any localised damage regions have radar enabled, set the visibility.
if (shipInstance.shipDamageModel == Ship.ShipDamageModel.Localised)
{
for (int dmIdx = 0; dmIdx < shipInstance.numLocalisedDamageRegions; dmIdx++)
{
DamageRegion damageRegion = shipInstance.localisedDamageRegionList[dmIdx];
if (damageRegion != null && damageRegion.isRadarEnabled)
{
sscRadar.SetVisibility(damageRegion.radarItemIndex, isEnabled);
}
}
}
// Added for TechDemo3 (SSC v1.2.6 Beta 1b)
if (isEnabled && isInitialised)
{
shipInstance.UpdatePositionAndMovementData(transform, rBody);
// Update fields that may change at any time
shipInstance.sscRadarPacket.isVisibleToRadar = true;
shipInstance.sscRadarPacket.position = shipInstance.TransformPosition;
shipInstance.sscRadarPacket.velocity = shipInstance.WorldVelocity;
shipInstance.sscRadarPacket.factionId = shipInstance.factionId;
shipInstance.sscRadarPacket.squadronId = shipInstance.squadronId;
// Use the internal radarItemIndex rather than RadarId to avoid the property lookup
sscRadar.UpdateItem(shipInstance.radarItemIndex, shipInstance.sscRadarPacket);
}
}
#endregion
// Update the shipIsEnabled variable
shipIsEnabled = isEnabled;
// Movement is a subset of the ship being enabled/disabled.
isMovementEnabled = isEnabled && !isDocked;
}
/// <summary>
/// This is a subset of EnableOrDisableShip(...). The ship can still incur damage,
/// be destroyed and respawn (and become Enabled), and appear on Radar.
/// It applies to:
/// 1) Physics
/// 2) Thruster Effects
/// 3) User or AI Input to the Ship
/// 4) Sound FX (audio)
/// Movement is not enabled if the ship is docked, although collision detection is updated.
/// </summary>
/// <param name="isEnabled"></param>
/// <param name="resetVelocity"></param>
private void EnableOrDisableShipMovement(bool isEnabled, bool resetVelocity)
{
// This does not prove the ship is docked, but the ship thinks it is docked. For absolute proof, we would
// need to check the ShipDockingStation's docking points (which is prob too expensive here).
bool isDocked = isShipDockingAttached && shipDocking.IsInitialised && shipDocking.GetStateInt() == ShipDocking.dockedInt;
if (isDocked && isEnabled)
{
ShipRigidbody.detectCollisions = shipDocking.detectCollisionsWhenDocked;
}
else
{
EnableOrDisableShipPhysics(isEnabled, resetVelocity);
PauseOrResumeThrusters(isEnabled);
if (!isEnabled && callbackOnRumble != null) { callbackOnRumble(0f); }
if (!isEnabled) { StopAudioSources(); }
isMovementEnabled = isEnabled;
}
}
/// <summary>
/// Enable or disable the Physics on a ship. If this ia an AI ship, resets the PID controllers
/// when isEnabled is true.
/// If resetVelocity and isEnabled are true, resets the velocity of the ship to zero.
/// NOTE: This should NOT be called when the ship is docked.
/// </summary>
/// <param name="isEnabled"></param>
/// <param name="resetVelocity"></param>
private void EnableOrDisableShipPhysics(bool isEnabled, bool resetVelocity)
{
// Ensure the rigidbody's collision detection mode is configured to permit isKinematic.
if (!isEnabled) { ShipRigidbody.collisionDetectionMode = CollisionDetectionMode.Discrete; }
if (isEnabled)
{
// When enabling, turn on collisions and set the ship rigidbody to not kinematic
ShipRigidbody.detectCollisions = true;
ShipRigidbody.isKinematic = false;
// Re-configure the rigidbody's collision detection mode
ShipRigidbody.collisionDetectionMode = CollisionDetectionMode.ContinuousDynamic;
}
else
{
// When disabling, turn off collisions and set the ship rigidbody to kinematic
ShipRigidbody.detectCollisions = false;
ShipRigidbody.isKinematic = true;
// Added 1.3.7 Beta 5c so that cached velo data correctly returns Vector.Zero
// NOTE: This hasn't been fully regression tested.
if (resetVelocity) { shipInstance.ResetVelocityData(); }
}
// Set our velocity when we enable the ship
if (isEnabled)
{
if (resetVelocity)
{
// Reset velocity to zero
ShipRigidbody.velocity = Vector3.zero;
ShipRigidbody.angularVelocity = Vector3.zero;
// If there is an AI component attached, reset the PID controllers
if (isShipAIInputModuleAttached && shipAIInputModule != null)
{
if (shipAIInputModule.IsInitialised) { shipAIInputModule.ResetPIDControllers(); }
else { shipAIInputModule.Initialise(); }
}
}
else
{
// Set velocity to the velocity we had before the ship was disabled
// NOTE: This assumes shipInstance.ResetVelocityData() isn't called when this method
// is called with isEnabled = true.
ShipRigidbody.velocity = shipInstance.WorldVelocity;
ShipRigidbody.angularVelocity = shipInstance.WorldAngularVelocity;
}
}
}
/// <summary>
/// Pause or Resume (play) all Thruster Effects on the ship
/// </summary>
/// <param name="isEnabled"></param>
private void PauseOrResumeThrusters(bool isEnabled)
{
arrayLength = thrusterEffects == null ? 0 : thrusterEffects.Length;
for (componentIndex = 0; componentIndex < arrayLength; componentIndex++)
{
if (thrusterEffects[componentIndex] != null)
{
if (isEnabled) { thrusterEffects[componentIndex].Play(); }
else { thrusterEffects[componentIndex].Pause(); }
}
}
}
/// <summary>
/// Find and stop all audio sources
/// </summary>
private void StopAudioSources()
{
// Use the pre-defined reuseable list to minmize GC
GetComponentsInChildren(audioSourcesList);
arrayLength = audioSourcesList.Count;
for (componentIndex = 0; componentIndex < arrayLength; componentIndex++)
{
if (audioSourcesList[componentIndex].enabled && audioSourcesList[componentIndex].isPlaying)
{
audioSourcesList[componentIndex].Stop();
}
}
}
/// <summary>
/// CURRENTLY NOT USED - FOR TESTING ONLY
/// </summary>
/// <returns></returns>
private IEnumerator RBodyReset()
{
//rBody.velocity = transform.TransformDirection(shipInstance.respawnVelocity);
rBody.velocity = Vector3.zero;
rBody.angularVelocity = Vector3.zero;
yield return new WaitForFixedUpdate();
}
/// <summary>
/// A ship can be considered stuck if it is enabled, initialised, respawnStuckTime > 0
/// and it is trying to move for respawnStuckTime but cannot.
/// </summary>
/// <returns></returns>
private bool IsShipStuck()
{
if (!shipIsEnabled || !isInitialised || shipInstance.stuckTime <= 0f) { return false; }
else
{
// velo in m/s
if (Mathf.Abs((shipInstance.TransformInverseRotation * shipInstance.WorldVelocity).z) > shipInstance.stuckSpeedThreshold)
{
stuckTimer = 0f;
return false;
}
else
{
stuckTimer += Time.deltaTime;
return stuckTimer >= shipInstance.stuckTime;
}
}
}
/// <summary>
/// Respawn (move) the ship to the closest point on the given Path.
/// The ship must be initialised and the Path must be valid.
/// </summary>
/// <param name="pathguidHash"></param>
/// <param name="updateVisibility"></param>
/// <param name="resetVelocity"></param>
private void RespawnOnPath(int pathguidHash, bool updateVisibility, bool resetVelocity)
{
if (isInitialised && pathguidHash != 0)
{
PathData pathData = sscManager.GetPath(pathguidHash);
if (pathData != null)
{
Vector3 closestPointOnPath = Vector3.zero;
float closestPointOnPathTValue = 0f;
int prevPathLocationIdx = 0;
if (SSCMath.FindClosestPointOnPath(pathData, shipInstance.TransformPosition, ref closestPointOnPath, ref closestPointOnPathTValue, ref prevPathLocationIdx))
{
DisableShip(updateVisibility);
// Check for closest object
float lookDistance = 10f, minDistance = 10000f;
RaycastHit raycastHit;
Vector3 objectNormal = Vector3.zero;
Ray ray = new Ray(closestPointOnPath, Vector3.up);
SSCUtils.GetClosestCollider(ray, Vector3.up, lookDistance, ref minDistance, ref objectNormal, out raycastHit);
SSCUtils.GetClosestCollider(ray, Vector3.down, lookDistance, ref minDistance, ref objectNormal, out raycastHit);
SSCUtils.GetClosestCollider(ray, Vector3.left, lookDistance, ref minDistance, ref objectNormal, out raycastHit);
SSCUtils.GetClosestCollider(ray, Vector3.right, lookDistance, ref minDistance, ref objectNormal, out raycastHit);
SSCUtils.GetClosestCollider(ray, Vector3.forward, lookDistance, ref minDistance, ref objectNormal, out raycastHit);
SSCUtils.GetClosestCollider(ray, Vector3.back, lookDistance, ref minDistance, ref objectNormal, out raycastHit);
if (objectNormal.sqrMagnitude > 0.01f)
{
Vector3 pathTangent = Vector3.zero;
// Get the direction of the path so ship faces in the correct direction AND is orientated upwards similar to closest object.
if (SSCMath.GetPathTangent(pathData, prevPathLocationIdx, closestPointOnPathTValue, ref pathTangent))
{
transform.SetPositionAndRotation(closestPointOnPath, Quaternion.LookRotation(pathTangent, objectNormal));
}
else
{
transform.SetPositionAndRotation(closestPointOnPath, Quaternion.Euler(objectNormal));
}
}
else { transform.position = closestPointOnPath; }
EnableShip(updateVisibility, resetVelocity);
}
}
}
}
/// <summary>
/// Check to see if there is a ShipAIInputModule attached to this ship.
/// </summary>
private void FetchShipAIInputModule()
{
isShipAIInputModuleAttached = TryGetComponent(out shipAIInputModule);
//shipAIInputModule = GetComponent<ShipAIInputModule>();
//isShipAIInputModuleAttached = shipAIInputModule != null;
}
/// <summary>
/// Check to see if there is a ShipDocking component attached to this ship
/// </summary>
private void FetchShipDocking()
{
isShipDockingAttached = TryGetComponent(out shipDocking);
//shipDocking = GetComponent<ShipDocking>();
//isShipDockingAttached = shipDocking != null;
}
/// <summary>
/// [INTERNAL ONLY] Initialise radar for this ship
/// Assumes shipInstance is not null and that
/// sscRadar = SSCRadar.GetOrCreateRadar() has already
/// been called.
/// </summary>
private void InitialiseRadar()
{
// Not assigned in the radar system
shipInstance.radarItemIndex = -1;
if (shipInstance.isRadarEnabled && sscRadar != null)
{
SSCRadarItem sscRadarItem = new SSCRadarItem();
// No data from the ship yet, so hide it from radar
sscRadarItem.isVisibleToRadar = false;
sscRadarItem.blipSize = shipInstance.radarBlipSize;
sscRadarItem.shipControlModule = this;
// Create a packet to be used to send data to the radar system
shipInstance.sscRadarPacket = new SSCRadarPacket();
shipInstance.radarItemIndex = sscRadar.AddItem(sscRadarItem);
}
}
/// <summary>
/// [INTERNAL ONLY] Initialise radar for a localised damage region.
/// Assumes shipInstance is not null, and that
/// sscRadar = SSCRadar.GetOrCreateRadar() has already been called.
/// </summary>
private void InitialiseLocalDamageRegionRadar(DamageRegion damageRegion)
{
// Not assigned in the radar system
damageRegion.radarItemIndex = -1;
if (shipInstance.isRadarEnabled && damageRegion.isRadarEnabled && sscRadar != null)
{
SSCRadarItem sscRadarItem = new SSCRadarItem();
// No data from the ship damage region yet, so hide it from radar
sscRadarItem.isVisibleToRadar = false;
sscRadarItem.blipSize = 1;
sscRadarItem.shipControlModule = this;
// The damage region child transform can be used to help determine LoS. It may not be set.
sscRadarItem.itemGameObject = damageRegion.regionChildTransform == null ? null : damageRegion.regionChildTransform.gameObject;
sscRadarItem.radarItemType = SSCRadarItem.RadarItemType.ShipDamageRegion;
sscRadarItem.guidHash = damageRegion.guidHash;
// Create a packet to be used to send data to the radar system
damageRegion.sscRadarPacket = new SSCRadarPacket();
damageRegion.radarItemIndex = sscRadar.AddItem(sscRadarItem);
}
}
/// <summary>
/// If muzzle FX on weapons are pooled and have been parented to the weapons, when a
/// ship or damage region is destroyed (o rmade inactive), they need to be reparented to the pool.
/// NOTE: This may impact GC
/// </summary>
private void DestroyFX (Transform tfm)
{
EffectsModule[] effectsModules = tfm.GetComponentsInChildren<EffectsModule>(true);
int numEffectsModules = effectsModules == null ? 0 : effectsModules.Length;
for (int emIdx = 0; emIdx < numEffectsModules; emIdx++)
{
EffectsModule effectsModule = effectsModules[emIdx];
if (effectsModule.usePooling && effectsModule.isReparented)
{
effectsModule.DestroyEffectsObject();
}
}
}
/// <summary>
/// Automatically attempt to determine what kind of ship this is for use in the radar system.
/// Typically called after InitialiseRadar().
/// It defaults ot PlayerShip.
/// </summary>
private void RadarAutoSetType()
{
if (sscRadar != null)
{
if (isShipAIInputModuleAttached) { sscRadar.SetItemType(shipInstance.RadarId, SSCRadarItem.RadarItemType.AIShip); }
else { sscRadar.SetItemType(shipInstance.RadarId, SSCRadarItem.RadarItemType.PlayerShip); }
}
}
/// <summary>
/// Initiate a destruct prefab on a damage region of the ship
/// NOTE: sscManager must not be null when calling this method.
/// </summary>
/// <param name="damageRegion"></param>
/// <param name="isMainRegion"></param>
private void DestructDamageRegion(DamageRegion damageRegion, bool isMainRegion)
{
if (!damageRegion.isDestructObjectActivated && damageRegion.destructObjectPrefabID >= 0 && damageRegion.destructObject != null)
{
Vector3 destructPosition = shipInstance.TransformPosition;
Quaternion destructRotation = shipInstance.TransformRotation;
if (isMainRegion)
{
if (shipInstance.respawningMode == Ship.RespawningMode.DontRespawn)
{
// Turn off all colliders. As we are going to destroy the gameobject,
// we can simply deactivate it.
gameObject.SetActive(false);
}
else
{
// Cater for respawning - before DestructDamageRegion is called the ship is disabled
// with EnableOrDisableShip(false, true, false). Here we should not turn off the gameObject.
// This "seems" to work without having to disable the colliders but might need more testing.
}
}
else
{
// Get the worldspace position of the region
destructPosition = shipInstance.GetDamageRegionWSPosition(damageRegion);
// Damage region needs to be repairable
}
// Instantiate the region destruct prefab
InstantiateDestructParameters dstParms = new InstantiateDestructParameters
{
destructPrefabID = damageRegion.destructObjectPrefabID,
position = destructPosition,
rotation = destructRotation,
explosionPowerFactor = 1f,
explosionRadiusFactor = 1f
};
// Keep track of the DestructModule instance that was instantiated for this region
if (sscManager.InstantiateDestruct(ref dstParms) != null)
{
damageRegion.destructItemKey = new SSCDestructItemKey(damageRegion.destructObjectPrefabID, dstParms.destructPoolListIndex, dstParms.destructSequenceNumber);
}
damageRegion.isDestructObjectActivated = true;
}
}
/// <summary>
/// Update the Thruster Effects
/// </summary>
private void UpdateThrusterFX()
{
arrayLength = thrusterEffects == null ? 0 : thrusterEffects.Length;
Vector3 localVelo = shipInstance.LocalVelocity;
for (componentIndex = 0; componentIndex < arrayLength; componentIndex++)
{
if (thrusterEffects[componentIndex] != null)
{
thrusterEffects[componentIndex].UpdateThrusterInput(shipInstance.thrusterList[componentIndex], localVelo);
}
}
}
#endregion
#region Events
// Called when the ship rigidbody collides with another collider
private void OnCollisionEnter(Collision collision)
{
if (callbackOnCollision != null) { callbackOnCollision.Invoke(this, collision); }
else { shipInstance.ApplyCollisionDamage(collision); }
}
#endregion
#region Public API Methods - Initialisation
/// <summary>
/// Runs all necessary initialisation processes for the ship.
/// </summary>
public void InitialiseShip()
{
if (!isInitialised)
{
// Find the rigidbody
rBody = GetComponent<Rigidbody>();
// Cater for scenario where [RequireComponent(typeof(Rigidbody))] doesn't work
// RequireComponent only seems to work when first adding the script to a gameobject.
if (rBody == null) { isInitialised = false; return; }
// Configure the rigidbody
rBody.drag = 0f;
rBody.angularDrag = 0f;
rBody.useGravity = false;
rBody.isKinematic = false;
rBody.collisionDetectionMode = CollisionDetectionMode.ContinuousDynamic;
// Set the mass and centre of mass of the ship
ReinitialiseMass();
// Initialise all necessary ship data
shipInstance.UpdatePositionAndMovementData(transform, rBody);
shipInstance.Initialise(transform);
// Initialise ship health
shipInstance.ResetHealth();
ReinitialiseThrusterEffects();
if (!shipInstance.isThrusterSystemsStarted)
{
StopThrusterEffects();
}
// Get a reference to the Ship Controller Manager instance
sscManager = SSCManager.GetOrCreateManager();
// Initialise projectiles and effects objects
ReinitialiseShipProjectilesAndEffects();
// Initialise beam weapons and the effects objects used by those weapons.
ReinitialiseShipBeams();
// Initialise destruct objects used by damage regions
ReinitialiseShipDestructObjects();
// Initialise required lists
// Pre-size the list of renderers that is used when
// ships are disable/enabled during respawing. If the list
// is too small, it be expanded the first time it is used (and affect GC).
activeRenderersList = new List<Renderer>(5);
// Assume only 1 audio source per ship. Will auto expand if required.
// Increase the capacity of the list if ships tend to have more audio sources.
audioSourcesList = new List<AudioSource>(1);
FetchShipAIInputModule();
FetchShipDocking();
if (shipInstance.isRadarEnabled)
{
sscRadar = SSCRadar.GetOrCreateRadar();
InitialiseRadar();
RadarAutoSetType();
if (shipInstance.shipDamageModel == Ship.ShipDamageModel.Localised)
{
for (int dmIdx = 0; dmIdx < shipInstance.numLocalisedDamageRegions; dmIdx++)
{
InitialiseLocalDamageRegionRadar(shipInstance.localisedDamageRegionList[dmIdx]);
}
}
}
isInitialised = true;
}
}
/// <summary>
/// Reinitialises variables related to the mass of the ship.
/// Call after modifying shipInstance.mass or shipInstance.centreOfMass.
/// </summary>
public void ReinitialiseMass()
{
// Set the mass and centre of mass of the ship
rBody.mass = shipInstance.mass;
rBody.centerOfMass = shipInstance.centreOfMass;
}
/// <summary>
/// Reinitialises variables required for projectiles and effects of the ship.
/// Call this after modifying any projectile or effect data for this ship.
/// </summary>
public void ReinitialiseShipProjectilesAndEffects()
{
if (sscManager != null)
{
// Initialise projectiles and effects objects
sscManager.UpdateProjectilesAndEffects(shipInstance);
}
#if UNITY_EDITOR
else
{
Debug.LogWarning("ShipControlModule.ReinitialiseShipProjectilesAndEffects Warning: could not find SSCManager to update projectiles and effects.");
}
#endif
}
/// <summary>
/// Reinitialises variables required for destruct objects of the ship.
/// Call after modifying any destruct data for this ship.
/// </summary>
public void ReinitialiseShipDestructObjects ()
{
if (sscManager != null)
{
// Initialise destruct objects
sscManager.UpdateDestructObjects(shipInstance);
}
#if UNITY_EDITOR
else
{
Debug.LogWarning("ShipControlModule.ReinitialiseShipDestructObjects Warning: could not find SSCManager to update destruct objects.");
}
#endif
}
/// <summary>
/// Reinitialises variables required for ship beam weapons and effects used by those beams.
/// Call this after modifying any beams or beam effect data for this ship.
/// </summary>
public void ReinitialiseShipBeams()
{
if (sscManager != null)
{
// Initialise beams, and effects objects used by those beams
sscManager.UpdateBeamsAndEffects(shipInstance);
}
#if UNITY_EDITOR
else
{
Debug.LogWarning("ShipControlModule.ReinitialiseShipBeams Warning: could not find SSCManager to update (weapon) beams");
}
#endif
}
/// <summary>
/// Reinitialises the thruster effects for a ship.
/// Call this after modifying thruster effects objects for this ship.
/// WARNING: This will generate Garbage so use sparingly.
/// </summary>
public void ReinitialiseThrusterEffects()
{
// Initialise all thruster effects
arrayLength = shipInstance.thrusterList == null ? 0 : shipInstance.thrusterList.Count;
int numThrusterEffects = thrusterEffects == null ? 0 : thrusterEffects.Length;
if (arrayLength > 0)
{
// There is a list of thrusterEffectObjects. Each thruster has a slot however it also may be null if the thruster has no effects parent gameobject.
// Each thruster should have a single ThrusterEffects slot (which could be null if thruster has no effects parent gameobject in the scene)
// One ThrusterEffects component is added the to thruster effects parent gameobject (if there is one) for each Thruster in the scene.
// Each ThrusterEffects component is then initialised.
if (numThrusterEffects == 0) { thrusterEffects = new ThrusterEffects[arrayLength]; }
else if (arrayLength != numThrusterEffects) { System.Array.Resize(ref thrusterEffects, arrayLength); }
numThrusterEffects = thrusterEffects == null ? 0 : thrusterEffects.Length;
for (componentIndex = 0; componentIndex < arrayLength; componentIndex++)
{
if (thrusterEffectObjects[componentIndex] != null)
{
// Check if the ThrusterEffects component has previously been added. If not, add it now.
ThrusterEffects thrusterEffect = thrusterEffectObjects[componentIndex].GetComponent<ThrusterEffects>();
if (thrusterEffect == null) { thrusterEffect = thrusterEffectObjects[componentIndex].AddComponent<ThrusterEffects>(); }
thrusterEffects[componentIndex] = thrusterEffect;
thrusterEffects[componentIndex].Initialise();
}
else
{
//thrusterEffects[componentIndex].Clear();
}
}
}
else
{
// Clean up old thruster effect class instances
if (numThrusterEffects > 0)
{
for (componentIndex = 0; componentIndex < numThrusterEffects; componentIndex++)
{
thrusterEffects[componentIndex].Clear();
}
System.Array.Clear(thrusterEffects, 0, numThrusterEffects);
}
thrusterEffects = null;
}
}
#endregion
#region Public API Methods - Reset, Enable, Disable Ship
/// <summary>
/// A fast way of re-initialising a ship without changing its position or core
/// settings. Typically called when re-initialising a scene or bringing a ship
/// out of hibernation. If you want to temporarily stop a ship from moving, like
/// when a user brings up a menu, call DisableShip() and EnableShip() instead.
/// </summary>
public void ResetShip()
{
// Temporily prevent other things from occuring
isInitialised = false;
// Disable ship but don't make it invisible. Reset velocity
EnableOrDisableShip(false, false, true);
// Stop all Thrusters on the ship
arrayLength = thrusterEffects == null ? 0 : thrusterEffects.Length;
for (componentIndex = 0; componentIndex < arrayLength; componentIndex++)
{
if (thrusterEffects[componentIndex] != null)
{
thruster = shipInstance.thrusterList[componentIndex];
if (thruster != null) { thrusterEffects[componentIndex].Stop(); }
}
}
isRespawning = false;
// (Re)initialise all necessary ship data
shipInstance.UpdatePositionAndMovementData(transform, rBody);
// NOTE: This may cause issues with Radar as it sets radarItemIndex = -1
// If we see a problem, maybe we need to remove from radar first.
shipInstance.Initialise(transform);
// Reset the health of the ship
shipInstance.ResetHealth();
// Get the last damage event index of the ship
lastDamageEventIndex = shipInstance.LastDamageEventIndex();
// Reset rumble
damageRumbleTimer = -1f;
isInitialised = true;
}
/// <summary>
/// Enables the ship and make visible.
/// If resetVelocity is set to true, resets the velocity of the ship to zero.
/// </summary>
/// <param name="resetVelocity"></param>
public void EnableShip (bool resetVelocity)
{
EnableOrDisableShip(true, true, resetVelocity);
}
/// <summary>
/// Enables the ship. If updateVisibility is set to true, makes the ship visible.
/// If resetVelocity is set to true, resets the velocity of the ship to zero.
/// </summary>
/// <param name="updateVisibility"></param>
/// <param name="resetVelocity"></param>
public void EnableShip(bool updateVisibility, bool resetVelocity)
{
EnableOrDisableShip(true, updateVisibility, resetVelocity);
}
public bool IsActive => isActive;
private bool isActive = false;
public void LittleEnableShip()
{
isActive = true;
}
public void LittleDisableShip()
{
isActive = false;
}
/// <summary>
/// Disables the ship. If updateVisibility is set to true, makes the ship invisible.
/// </summary>
/// <param name="updateVisibility"></param>
public void DisableShip(bool updateVisibility)
{
EnableOrDisableShip(false, updateVisibility, false);
}
/// <summary>
/// Returns whether the ship is currently enabled. When disabled, it
/// cannot move, be visible or radar, nor received damage and be destroyed.
/// </summary>
/// <returns></returns>
public bool ShipIsEnabled()
{
return shipIsEnabled;
}
#endregion
#region Public API Methods - Enable, Disable Ship Movement
/// <summary>
/// Returns whether the ship movement is curently enabled.
/// See also ShipIsEnabled(). A ship's movement may be disabled
/// while it can still receive damaage, be destroyed or be visible
/// to radar.
/// </summary>
/// <returns></returns>
public bool ShipMovementIsEnabled()
{
return isMovementEnabled;
}
/// <summary>
/// This is a subset of EnableShip(...).
/// It only applies to:
/// 1) Physics
/// 2) Thruster Effects
/// 3) User or AI Input to the Ship
/// 4) Sound FX (audio)
/// If a ship is also disabled, this will re-enable the ship.
/// </summary>
/// <param name="resetVelocity"></param>
public void EnableShipMovement(bool resetVelocity)
{
if (isInitialised)
{
if (!shipIsEnabled) { EnableOrDisableShip(true, true, resetVelocity); }
else { EnableOrDisableShipMovement(true, resetVelocity); }
}
}
/// <summary>
/// This is a subset of DisableShip(...).
/// It only applies to:
/// 1) Physics
/// 2) Thruster Effects
/// 3) User or AI Input to the Ship
/// 4) Sound FX (audio)
/// </summary>
public void DisableShipMovement()
{
if (isInitialised)
{
EnableOrDisableShipMovement(false, false);
}
}
/// <summary>
/// Teleport the ship to a new location by moving by an amount
/// in the x, y and z directions. This could be useful if changing
/// the origin or centre of your world to compensate for float-point
/// error.
/// NOTE: This does not alter the current Respawn position.
/// </summary>
/// <param name="delta"></param>
/// <param name="resetVelocity"></param>
public void TelePort (Vector3 delta, bool resetVelocity)
{
// Remember current situation of the ship
bool isMovementEnabled = false;
if (isInitialised) { DisableShipMovement(); isMovementEnabled = true; }
transform.position += delta;
// If movement was enabled, re-enable it
if (isMovementEnabled) { EnableShipMovement(resetVelocity); }
}
/// <summary>
/// Teleport the ship to a new location with a new rotation.
/// NOTE: This does not alter the current Respawn position.
/// </summary>
/// <param name="newPosition"></param>
/// <param name="newRotation"></param>
/// <param name="resetVelocity"></param>
public void TelePort (Vector3 newPosition, Quaternion newRotation, bool resetVelocity)
{
// Remember current situation of the ship
bool isMovementEnabled = false;
if (isInitialised) { DisableShipMovement(); isMovementEnabled = true; }
transform.SetPositionAndRotation(newPosition, newRotation);
// If movement was enabled, re-enable it
if (isMovementEnabled) { EnableShipMovement(resetVelocity); }
}
#endregion
#region Public API Methods - Respawning
/// <summary>
/// If the ship is currently respawning, this will stop
/// the countdown timer, preventing the ship from respawning
/// until ResumeRespawning() is called.
/// NOTE: Has no effect if not already respawning.
/// </summary>
public void PauseRespawning()
{
if (isRespawning) { isRespawingPaused = true; }
}
/// <summary>
/// If respawning is currently paused, the respawning
/// timer will now continue until the ship is respawned.
/// NOTE: Has no effect if respawningMode is DontRespawn
/// </summary>
public void ResumeRespawning()
{
isRespawingPaused = false;
}
#endregion
#region Public API Methods - Radar
/// <summary>
/// The ship will no longer send tracking information to the radar system.
/// If you want to change the visibility to other radar consumers, consider
/// changing the radar item data rather than disabling the radar and (later)
/// calling EnableRadar again. When using a Localised ShipDamageModel, it
/// will also disable radar on all localised Damage Regions.
/// </summary>
public void DisableRadar()
{
if (isInitialised)
{
if (shipInstance.isRadarEnabled && sscRadar != null && sscRadar.IsInitialised)
{
// If enabled, remove the localised damage regions from radar
if (shipInstance.shipDamageModel == Ship.ShipDamageModel.Localised)
{
for (int dmIdx = 0; dmIdx < shipInstance.numLocalisedDamageRegions; dmIdx++)
{
DisableRadar(shipInstance.localisedDamageRegionList[dmIdx]);
}
}
// Remove this ship from radar
sscRadar.RemoveItem(shipInstance.radarItemIndex);
}
shipInstance.sscRadarPacket = null;
shipInstance.isRadarEnabled = false;
shipInstance.radarItemIndex = -1;
}
sscRadar = null;
}
/// <summary>
/// The ship will no longer send tracking information to the radar system for this
/// damage region. If you want to change the visibility to other radar consumers, consider
/// changing the radar item data rather than disabling the radar and (later)
/// calling EnableRadar(damageRegion) again.
/// NOTE: You do not need to call this if calling DisableRadar() for the ship.
/// </summary>
/// <param name="damageRegion"></param>
public void DisableRadar(DamageRegion damageRegion)
{
if (damageRegion != null)
{
if (damageRegion.isRadarEnabled && damageRegion.radarItemIndex >= 0)
{
sscRadar.RemoveItem(damageRegion.radarItemIndex);
}
damageRegion.sscRadarPacket = null;
damageRegion.isRadarEnabled = false;
damageRegion.radarItemIndex = -1;
}
}
/// <summary>
/// Enable the ship to send tracking information to the
/// radar system. The ship must first be initialised.
/// </summary>
public void EnableRadar()
{
if (isInitialised)
{
sscRadar = SSCRadar.GetOrCreateRadar();
if (sscRadar != null)
{
shipInstance.isRadarEnabled = true;
InitialiseRadar();
RadarAutoSetType();
}
}
}
/// <summary>
/// Enable the ship to send tracking information to the radar system
/// for this damage region. The ship must be initialised and radar must
/// already be enabled for the ship. See also EnableRadar().
/// </summary>
/// <param name="damageRegion"></param>
public void EnableRadar(DamageRegion damageRegion)
{
if (isInitialised && damageRegion.radarItemIndex == -1)
{
InitialiseLocalDamageRegionRadar(damageRegion);
damageRegion.isRadarEnabled = damageRegion.radarItemIndex >= 0;
}
}
#endregion
#region Public API Methods - Ship Input
/// <summary>
/// Provide an instance of shipInput, and have it populated with the current values from the ship.
/// </summary>
/// <param name="shipInput"></param>
public void GetShipInput (ShipInput shipInput)
{
if (shipInput != null)
{
shipInput.horizontal = pilotForceInput.x;
shipInput.vertical = pilotForceInput.y;
shipInput.longitudinal = pilotForceInput.z;
shipInput.pitch = pilotMomentInput.x;
shipInput.yaw = pilotMomentInput.y;
shipInput.roll = pilotMomentInput.z;
shipInput.primaryFire = pilotPrimaryFireInput;
shipInput.secondaryFire = pilotSecondaryFireInput;
shipInput.dock = pilotDockInput;
}
}
/// <summary>
/// Sends the specified input to the ship control module in order to control the ship.
/// By default all data inputs should be enabled even when sending 0 values.
/// </summary>
/// <param name="shipInput"></param>
public void SendInput(ShipInput shipInput)
{
if (shipInput.isHorizontalDataEnabled) { pilotForceInput.x = shipInput.horizontal; }
if (shipInput.isVerticalDataEnabled) { pilotForceInput.y = shipInput.vertical; }
if (shipInput.isLongitudinalDataEnabled) { pilotForceInput.z = shipInput.longitudinal; }
if (shipInput.isPitchDataEnabled) { pilotMomentInput.x = shipInput.pitch; }
if (shipInput.isYawDataEnabled) { pilotMomentInput.y = shipInput.yaw; }
if (shipInput.isRollDataEnabled) { pilotMomentInput.z = shipInput.roll; }
if (shipInput.isPrimaryFireDataEnabled) { pilotPrimaryFireInput = shipInput.primaryFire; }
if (shipInput.isSecondaryFireDataEnabled) { pilotSecondaryFireInput = shipInput.secondaryFire; }
if (shipInput.isDockDataEnabled) { pilotDockInput = shipInput.dock; }
}
#endregion
#region Public API Methods - Docking
/// <summary>
/// Is the ShipDocking component attached to this ship, and if so, is the ship's state 'Docked'?
/// NOTE: This does not mean it must be docked with a ShipDockingStation. For that, you would
/// need to check the ShipDockingStation's docking points.
/// </summary>
/// <returns></returns>
public bool ShipIsDocked()
{
return isShipDockingAttached && shipDocking.GetState() == ShipDocking.DockingState.Docked;
}
/// <summary>
/// Is the ShipDocking component attached to this ship, and if so, is the ship's state 'Not Docked'?
/// NOTE: This does not mean it must be not docked with a ShipDockingStation. For that, you would
/// need to check the ShipDockingStation's docking points.
/// </summary>
/// <returns></returns>
public bool ShipIsNotDocked()
{
return isShipDockingAttached && shipDocking.GetStateInt() == ShipDocking.notDockedInt;
}
/// <summary>
/// Retrieves a reference to the ShipDocking script if one was attached at the time this
/// module was initiated.
/// </summary>
/// <param name="forceCheck">Ignore cached value and call GetComponent when true</param>
/// <returns></returns>
public ShipDocking GetShipDocking(bool forceCheck = false)
{
if (forceCheck) { FetchShipDocking(); }
return isShipDockingAttached ? shipDocking : null;
}
#endregion
#region Public API Methods - Ship AI
/// <summary>
/// Retrieves a reference to the ShipAIInputModule script if one was attached at the time
/// this module was initialised.
/// </summary>
/// <param name="forceCheck">Ignore cached value and call GetComponent when true</param>
/// <returns></returns>
public ShipAIInputModule GetShipAIInputModule(bool forceCheck = false)
{
if (forceCheck) { FetchShipAIInputModule(); }
return isShipAIInputModuleAttached ? shipAIInputModule : null;
}
#endregion
#region Public API Methods - Thrusters
/// <summary>
/// Add 1 second of forward boost.
/// See also StopBoost().
/// For more control, see shipInstance.AddBoost(..).
/// </summary>
/// <param name="forceAmountKNeutons"></param>
public void AddBoost (float forceAmountKNeutons, float time = 1)
{
if (isInitialised)
{
shipInstance.AddBoost(Vector3.forward, forceAmountKNeutons * 1000f, time);
}
}
public void MultiplyVelocity(float percent)
{
if (isInitialised)
{
rBody.velocity *= percent;
}
}
/// <summary>
/// Enable all the thruster effects where the gameobject contains the specified string.
/// Typically used to turn on an effect to improve the quality or look of a game.
/// Call ReinitialiseThrusterEffects() after calling 1 or more of these methods.
/// If you wish to enable or start a thruster, it is more likely you want to use EnableShip()
/// or EnableShipMovement().
/// WARNING: This will generate Garbage so use sparingly.
/// </summary>
/// <param name="effectNameContains"></param>
public void EnableThrusterEffects(string effectNameContains)
{
arrayLength = thrusterEffectObjects == null ? 0 : thrusterEffectObjects.Length;
// Look through all the thrusters for effects parent gameobjects
for (componentIndex = 0; componentIndex < arrayLength; componentIndex++)
{
GameObject thrusterEffectsGO = thrusterEffectObjects[componentIndex];
if (thrusterEffectsGO != null)
{
// If the top level effects gameobject contains the string, then disable it.
if (thrusterEffectsGO.name.Contains(effectNameContains)) { thrusterEffectsGO.SetActive(true); }
else
{
// Search through the child objects including inactive transforms
Transform[] childTrfms = thrusterEffectsGO.GetComponentsInChildren<Transform>(true);
int numChildren = childTrfms == null ? 0 : childTrfms.Length;
for (int t = 0; t < numChildren; t++)
{
if (childTrfms[t] != null && childTrfms[t].name.Contains(effectNameContains))
{
childTrfms[t].gameObject.SetActive(true);
}
}
}
}
}
}
/// <summary>
/// Disable all the thruster effects where the gameobject contains the specified string.
/// Typically used to turn off an effect to reduce the performance overhead of running it.
/// Call ReinitialiseThrusterEffects() after calling 1 or more of these methods.
/// If you wish to pause or stop a thruster, it is more likely you want to use DisableShip()
/// or DisableShipMovement().
/// WARNING: This will generate Garbage so use sparingly.
/// </summary>
/// <param name="effectNameContains"></param>
public void DisableThrusterEffects (string effectNameContains)
{
arrayLength = thrusterEffectObjects == null ? 0 : thrusterEffectObjects.Length;
// Look through all the thrusters for effects parent gameobjects
for (componentIndex = 0; componentIndex < arrayLength; componentIndex++)
{
GameObject thrusterEffectsGO = thrusterEffectObjects[componentIndex];
if (thrusterEffectsGO != null)
{
// If the top level effects gameobject contains the string, then disable it.
if (thrusterEffectsGO.name.Contains(effectNameContains)) { thrusterEffectsGO.SetActive(false); }
else
{
// Search through the child objects
Transform[] childTrfms = thrusterEffectsGO.GetComponentsInChildren<Transform>();
int numChildren = childTrfms == null ? 0 : childTrfms.Length;
for (int t = 0; t < numChildren; t++)
{
if (childTrfms[t] != null && childTrfms[t].name.Contains(effectNameContains))
{
childTrfms[t].gameObject.SetActive(false);
}
}
}
}
}
}
/// <summary>
/// Set the maximum volume for a given thruster. Numbers begin at 1. Values should be between 0.0 and 1.0.
/// </summary>
/// <param name="thrusterNumber"></param>
/// <param name="newMaxVolume"></param>
public void SetThrusterMaxVolume (int thrusterNumber, float newMaxVolume)
{
if (isInitialised && thrusterNumber > 0 && thrusterNumber <= (thrusterEffects == null ? 0 : thrusterEffects.Length))
{
if (thrusterEffects[thrusterNumber - 1] != null)
{
thrusterEffects[thrusterNumber - 1].SetMaxVolume(newMaxVolume);
}
}
}
/// <summary>
/// Begin to shut down the thrusters. Optionally override the shutdown duration.
/// </summary>
public void ShutdownThrusterSystems (bool isInstantShutdown = false)
{
if (isInitialised)
{
shipInstance.ShutdownThrusterSystems(isInstantShutdown);
//if (!shipInstance.isThrusterSystemsStarted)
{
UpdateThrusterFX();
//StopThrusterEffects();
}
}
}
/// <summary>
/// Begin to bring the thrusters online. Optionally, override the startup duration.
/// As soon as the systems begin to start up, shipInstance.isThrusterSystemsStarted will be true.
/// </summary>
/// <param name="isInstantStartup"></param>
public void StartupThrusterSystems (bool isInstantStartup = false)
{
if (isInitialised)
{
shipInstance.StartupThrusterSystems(isInstantStartup);
PauseOrResumeThrusters(true);
UpdateThrusterFX();
}
}
/// <summary>
/// Immediately stop any boost that has been applied with AddBoost(..).
/// </summary>
public void StopBoost()
{
if (isInitialised) { shipInstance.StopBoost(); }
}
/// <summary>
/// Stop all Thruster Effects on the ship
/// </summary>
public void StopThrusterEffects()
{
arrayLength = thrusterEffects == null ? 0 : thrusterEffects.Length;
for (componentIndex = 0; componentIndex < arrayLength; componentIndex++)
{
if (thrusterEffects[componentIndex] != null)
{
thrusterEffects[componentIndex].Stop();
}
}
}
#endregion
}
#region Public Structures
/// <summary>
/// Paramaters structure for CallbackOnHit (callback for Ship Control Module).
/// We do not recommend keeping references to any fields within this structure.
/// Use them in one frame, then discard them.
/// </summary>
public struct CallbackOnShipHitParameters
{
/// <summary>
/// Hit information for the raycast hit against the ship.
/// </summary>
public RaycastHit hitInfo;
/// <summary>
/// Prefab for the projectile that hit the ship.
/// </summary>
public ProjectileModule projectilePrefab;
/// <summary>
/// Prefab for the beam that hit the ship
/// </summary>
public BeamModule beamPrefab;
/// <summary>
/// Amount of damage done by the projectile or beam.
/// </summary>
public float damageAmount;
/// <summary>
/// The squadron ID of the ship that fired the projectile or beam.
/// </summary>
public int sourceSquadronId;
/// <summary>
/// Ship that fired the projectile or beam, else 0
/// </summary>
public int sourceShipId;
};
#endregion
}