/// <summary>
/// Adds a missile group that is targetting this ordnance group. typically PD
/// </summary>
/// <param name="MPD">Point defense missile group that is now targeted on this group.</param>
public void AddTargettingMissile(OrdnanceGroupTN MPD)
{
OrdGroupsTargetting.Add(MPD);
}
/// <summary>
/// when a targetting missile group needs to be removed(it has been intercepted or otherwise destroyed) this function handles that.
/// </summary>
/// <param name="MPD">Point defense missile Group</param>
public void RemoveTargettingMissile(OrdnanceGroupTN MPD)
{
if (OrdGroupsTargetting.Contains(MPD) == true)
{
OrdGroupsTargetting.Remove(MPD);
}
}
/// <summary>
/// Fire Weapons spawns new missiles groups or adds missiles to existing ones.
/// </summary>
/// <param name="TG">Taskgroup this MFC is in.</param>
/// <param name="FiredFrom">Ship these missiles were fired from.</param>
/// <returns>If missiles were fired at all from this MFC. true = atleast 1 missile(and therefore missile group, false = no missiles.</returns>
public bool FireWeapons(TaskGroupTN TG, ShipTN FiredFrom)
{
bool retv = false;
if (m_oTarget != null)
{
/// <summary>
/// Just a temporary variable for this function.
/// </summary>
BindingList<OrdnanceGroupTN> LocalMissileGroups = new BindingList<OrdnanceGroupTN>();
foreach (MissileLauncherTN LaunchTube in m_lLinkedWeapons)
{
if (LaunchTube.isDestroyed == false && LaunchTube.loadTime == 0 && LaunchTube.loadedOrdnance != null)
{
if (FiredFrom.ShipOrdnance.ContainsKey(LaunchTube.loadedOrdnance) == true)
{
OrdnanceTN newMissile = new OrdnanceTN(this, LaunchTube.loadedOrdnance, FiredFrom);
/// <summary>
/// Create a new missile group
/// </summary>
if (LocalMissileGroups.Count == 0)
{
OrdnanceGroupTN newMissileGroup = new OrdnanceGroupTN(TG, newMissile);
LocalMissileGroups.Add(newMissileGroup);
TG.TaskGroupFaction.MissileGroups.Add(newMissileGroup);
}
/// <summary>
/// An existing missile group may be useable.
/// </summary>
else
{
bool foundGroup = false;
foreach (OrdnanceGroupTN OrdGroup in LocalMissileGroups)
{
/// <summary>
/// All Missile groups should be composed of just 1 type of missile for convienence.
if (OrdGroup.missiles[0].missileDef.Id == LaunchTube.loadedOrdnance.Id)
{
OrdGroup.AddMissile(newMissile);
foundGroup = true;
break;
}
}
/// <summary>
/// Have to create a new missile group after all.
/// </summary>
if (foundGroup == false)
{
OrdnanceGroupTN newMissileGroup = new OrdnanceGroupTN(TG, newMissile);
LocalMissileGroups.Add(newMissileGroup);
TG.TaskGroupFaction.MissileGroups.Add(newMissileGroup);
}
}
/// <summary>
/// Decrement the loaded ordnance count, and remove the type entirely if this was the last one.
/// </summary>
FiredFrom.ShipOrdnance[LaunchTube.loadedOrdnance] = FiredFrom.ShipOrdnance[LaunchTube.loadedOrdnance] - 1;
if (FiredFrom.ShipOrdnance[LaunchTube.loadedOrdnance] == 0)
{
FiredFrom.ShipOrdnance.Remove(LaunchTube.loadedOrdnance);
}
/// <summary>
/// Set the launch tube cooldown time as a missile was just fired from it.
/// </summary>
LaunchTube.loadTime = LaunchTube.missileLauncherDef.rateOfFire;
/// <summary>
/// return that a missile was launched.
/// </summary>
retv = true;
}
else
{
String Msg = String.Format("No ordnance {0} on ship {1} is available for Launch Tube {2}", LaunchTube.Name, FiredFrom.Name, LaunchTube.Name);
MessageEntry newMessage = new MessageEntry(MessageEntry.MessageType.FiringNoAvailableOrdnance, TG.Contact.Position.System, TG.Contact,
GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Msg);
TG.TaskGroupFaction.MessageLog.Add(newMessage);
}
}
else if (LaunchTube.isDestroyed == true)
{
String Msg = String.Format("Destroyed launch tube {0} is still attached to {1}'s MFC", LaunchTube.Name, FiredFrom.Name);
MessageEntry newMessage = new MessageEntry(MessageEntry.MessageType.Error, TG.Contact.Position.System, TG.Contact,
GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Msg);
TG.TaskGroupFaction.MessageLog.Add(newMessage);
}
else if (LaunchTube.loadedOrdnance == null)
{
String Msg = String.Format("No loaded ordnance for launch tube {0} on ship {1}", LaunchTube.Name, FiredFrom.Name);
MessageEntry newMessage = new MessageEntry(MessageEntry.MessageType.FiringNoLoadedOrdnance, TG.Contact.Position.System, TG.Contact,
GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Msg);
TG.TaskGroupFaction.MessageLog.Add(newMessage);
}
}
return retv;
}
else
{
return false;
}
}
/// <summary>
/// Fire this MFC in point defense mode.
/// </summary>
/// <param name="TG">Taskgroup the MFC is in</param>
/// <param name="FiredFrom">Ship the MFC is on</param>
/// <param name="Target">Target of point defense fire.</param>
/// <param name="MissilesToFire">Number of missiles to fire at it</param>
/// <returns></returns>
public int FireWeaponsPD(TaskGroupTN TG, ShipTN FiredFrom, OrdnanceGroupTN Target, int MissilesToFire)
{
/// <summary>
/// simple stupid sanity check.
/// </summary>
if (MissilesToFire == 0)
{
return 0;
}
int LaunchCount = 0;
/// <summary>
/// Just a temporary variable for this function.
/// </summary>
BindingList<OrdnanceGroupTN> LocalMissileGroups = new BindingList<OrdnanceGroupTN>();
foreach (MissileLauncherTN LaunchTube in m_lLinkedWeapons) //int loop = 0; loop < LinkedWeapons.Count; loop++)
{
if (LaunchTube.isDestroyed == false && LaunchTube.loadTime == 0 && LaunchTube.loadedOrdnance != null)
{
if (FiredFrom.ShipOrdnance.ContainsKey(LaunchTube.loadedOrdnance) == true)
{
OrdnanceTN newMissile = new OrdnanceTN(this, LaunchTube.loadedOrdnance, FiredFrom);
/// <summary>
/// Point defense does not go by MFC targetting. have to add target here.
/// </summary>
newMissile.target = new TargetTN(Target);
LaunchCount++;
/// <summary>
/// Create a new missile group
/// </summary>
if (LocalMissileGroups.Count == 0)
{
OrdnanceGroupTN newMissileGroup = new OrdnanceGroupTN(TG, newMissile);
LocalMissileGroups.Add(newMissileGroup);
TG.TaskGroupFaction.MissileGroups.Add(newMissileGroup);
/// <summary>
/// Add this ordnance group to the ord groups targetting list for the intended target missile group.
/// This is only necessary here as Manually fired MFC missiles are connected to their MFC.
/// </summary>
Target.ordGroupsTargetting.Add(newMissileGroup);
}
/// <summary>
/// An existing missile group may be useable.
/// </summary>
else
{
bool foundGroup = false;
foreach (OrdnanceGroupTN OrdGroup in LocalMissileGroups)
{
/// <summary>
/// All Missile groups should be composed of just 1 type of missile for convienence.
if (OrdGroup.missiles[0].missileDef.Id == LaunchTube.loadedOrdnance.Id)
{
OrdGroup.AddMissile(newMissile);
foundGroup = true;
break;
}
}
/// <summary>
/// Have to create a new missile group after all.
/// </summary>
if (foundGroup == false)
{
OrdnanceGroupTN newMissileGroup = new OrdnanceGroupTN(TG, newMissile);
LocalMissileGroups.Add(newMissileGroup);
TG.TaskGroupFaction.MissileGroups.Add(newMissileGroup);
/// <summary>
/// Add this ordnance group to the ord groups targetting list for the intended target missile group.
/// This is only necessary here as Manually fired MFC missiles are connected to their MFC.
/// </summary>
Target.ordGroupsTargetting.Add(newMissileGroup);
}
}
/// <summary>
/// Decrement the loaded ordnance count, and remove the type entirely if this was the last one.
/// </summary>
FiredFrom.ShipOrdnance[LaunchTube.loadedOrdnance] = FiredFrom.ShipOrdnance[LaunchTube.loadedOrdnance] - 1;
if (FiredFrom.ShipOrdnance[LaunchTube.loadedOrdnance] == 0)
{
FiredFrom.ShipOrdnance.Remove(LaunchTube.loadedOrdnance);
}
/// <summary>
/// Set the launch tube cooldown time as a missile was just fired from it.
/// </summary>
LaunchTube.loadTime = LaunchTube.missileLauncherDef.rateOfFire;
if (LaunchCount == MissilesToFire)
break;
}
else
{
String Msg = String.Format("No ordnance {0} on ship {1} is available for Launch Tube {2} in PD Mode", LaunchTube.Name, FiredFrom.Name, LaunchTube.Name);
MessageEntry newMessage = new MessageEntry(MessageEntry.MessageType.FiringNoAvailableOrdnance, TG.Contact.Position.System, TG.Contact,
GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Msg);
TG.TaskGroupFaction.MessageLog.Add(newMessage);
}
}
else if (LaunchTube.isDestroyed == true)
{
String Msg = String.Format("Destroyed launch tube {0} is still attached to {1}'s MFC in PD Mode", LaunchTube.Name, FiredFrom.Name);
MessageEntry newMessage = new MessageEntry(MessageEntry.MessageType.Error, TG.Contact.Position.System, TG.Contact,
GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Msg);
TG.TaskGroupFaction.MessageLog.Add(newMessage);
}
else if (LaunchTube.loadedOrdnance == null)
{
String Msg = String.Format("No loaded ordnance for launch tube {0} on ship {1} in PD Mode", LaunchTube.Name, FiredFrom.Name);
MessageEntry newMessage = new MessageEntry(MessageEntry.MessageType.FiringNoLoadedOrdnance, TG.Contact.Position.System, TG.Contact,
GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Msg);
TG.TaskGroupFaction.MessageLog.Add(newMessage);
}
}
return LaunchCount;
}
/// <summary>
/// Simple assignment of a missile group as the target of this MFC
/// </summary>
/// <param name="OrdnanceTarget">missile group to be targetted.</param>
public void assignTarget(OrdnanceGroupTN OrdnanceTarget)
{
m_oTarget = new TargetTN(OrdnanceTarget);
}
/// <summary>
/// Assignment of a missile group as a target.
/// </summary>
/// <param name="OrdGroupTarget">ordnance group to be targetted</param>
public void assignTarget(OrdnanceGroupTN OrdGroupTarget)
{
TargetTN NewOrdTarget = new TargetTN(OrdGroupTarget);
m_oTarget = NewOrdTarget;
}
/// <summary>
/// Remove an ordnance group from the sim, and inform everyone targetted on or moving towards this of destruction.
/// </summary>
/// <param name="Owner">Owning faction</param>
/// <param name="OGRemove">Ordnance group to remove</param>
public void RemoveOrdnanceGroupFromSim(OrdnanceGroupTN OGRemove, BindingList<Faction> P)
{
/// <summary>
/// This ordnance group needs to be removed.
/// Ships Can be targeted on this ordnance group, from these ships missiles in flight can be tracked and informed.
/// </summary>
/// <summary>
/// Clear manually targetted Beam fire controls. neither area, nor final defense need to be cleared here.
/// </summary>
foreach (ShipTN nextShip in OGRemove.shipsTargetting)
{
foreach (BeamFireControlTN ShipBeamFC in nextShip.ShipBFC)
{
TargetTN BFCTarget = ShipBeamFC.getTarget();
if (BFCTarget != null)
{
if (BFCTarget.targetType == StarSystemEntityType.Missile && ShipBeamFC.pDState == PointDefenseState.None)
{
if (BFCTarget.missileGroup == OGRemove)
{
ShipBeamFC.clearTarget();
ShipBeamFC.openFire = false;
nextShip.ShipsFaction.OpenFireFC.Remove(ShipBeamFC);
nextShip.ShipsFaction.OpenFireFCType.Remove(ShipBeamFC);
}
}
}
}
/// <summary>
/// Clear manually targeted missile fire controls.
/// </summary>
foreach (MissileFireControlTN ShipMissileFC in nextShip.ShipMFC)
{
TargetTN MFCTarget = ShipMissileFC.getTarget();
if (MFCTarget != null)
{
if (MFCTarget.targetType == StarSystemEntityType.Missile && ShipMissileFC.pDState == PointDefenseState.None)
{
if (MFCTarget.missileGroup == OGRemove)
{
/// <summary>
/// Clear the target, set open fire to false, update the openFireFC list.
/// </summary>
ShipMissileFC.clearTarget();
ShipMissileFC.openFire = false;
nextShip.ShipsFaction.OpenFireFC.Remove(ShipMissileFC);
nextShip.ShipsFaction.OpenFireFCType.Remove(ShipMissileFC);
/// <summary>
/// Set all missiles to their own sensors.
/// </summary>
foreach (OrdnanceGroupTN MissileGroupInFlight in ShipMissileFC.missilesInFlight)
{
MissileGroupInFlight.CheckTracking();
}
}
}
}
}
/// <summary>
/// Clear the point defense missiles.
/// </summary>
foreach (OrdnanceGroupTN OrdnanceGroupTargetting in OGRemove.ordGroupsTargetting)
{
OrdnanceGroupTargetting.CheckTracking();
}
}
/// <summary>
/// Finally I need to remove the ordnance group from its faction list, all detection lists, from the system contact list, inform the Sceen to delete this contact, and clear the missile binding list.
/// Complicated stuff.
/// </summary>
foreach (Faction faction in P)
{
StarSystem CurSystem = OGRemove.contact.Position.System;
if (faction.DetectedContactLists.ContainsKey(CurSystem) == true)
{
if (faction.DetectedContactLists[CurSystem].DetectedMissileContacts.ContainsKey(OGRemove) == true)
{
faction.DetectedContactLists[CurSystem].DetectedMissileContacts.Remove(OGRemove);
}
}
if (faction.DetMissileList.Contains(OGRemove) == true)
{
faction.DetMissileList.Remove(OGRemove);
}
}
OGRemove.missilesDestroyed = 0;
OGRemove.missiles.Clear();
Faction Owner = OGRemove.ordnanceGroupFaction;
StarSystem CurrentSystem = OGRemove.contact.Position.System;
CurrentSystem.SystemContactList.Remove(OGRemove.contact);
Owner.MissileGroups.Remove(OGRemove);
}
/// <summary>
/// Constructor for Missile group targets.
/// </summary>
/// <param name="OGTarget">missile targeted on.</param>
public TargetTN(OrdnanceGroupTN OGTarget)
: base()
{
TargetType = OGTarget.SSEntity;
MissileGroup = OGTarget;
}
/// <summary>
/// Initializer for detected missile event. FactionContact is the detector side of what is detected, while OrdnanceTN itself stores the detectee side.
/// multiple of these can exist, but only 1 per faction hopefully.
/// </summary>
/// <param name="DetectedMissile">Missile detected.</param>
/// <param name="Thermal">Was the detection thermal based?</param>
/// <param name="em">Detection via EM?</param>
/// <param name="Active">Active detection?</param>
/// <param name="tick">What tick did this detection event occur on?</param>
public FactionContact(Faction CurrentFaction, OrdnanceGroupTN DetectedMissileGroup, bool Thermal, bool em, bool Active, uint tick)
{
missileGroup = DetectedMissileGroup;
ship = null;
pop = null;
thermal = Thermal;
EM = em;
EMSignature = 0;
active = Active;
MessageEntry NMsg;
String Contact = "New contact detected:";
if (thermal == true)
{
thermalTick = tick;
Contact = String.Format("{0} Thermal Signature {1} x{2}", Contact, (int)Math.Ceiling(DetectedMissileGroup.missiles[0].missileDef.totalThermalSignature), DetectedMissileGroup.missiles.Count);
}
if (EM == true)
{
EMTick = tick;
if (DetectedMissileGroup.missiles[0].missileDef.aSD != null)
{
EMSignature = DetectedMissileGroup.missiles[0].missileDef.aSD.gps;
Contact = String.Format("{0} EM Signature {1} x{2}", Contact, DetectedMissileGroup.missiles[0].missileDef.aSD.gps, DetectedMissileGroup.missiles.Count);
}
else
{
Contact = String.Format("Error with {0} : has EM signature but no active sensor.", Contact);
NMsg = new MessageEntry(MessageEntry.MessageType.Error, DetectedMissileGroup.contact.Position.System, DetectedMissileGroup.contact,
GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Contact);
CurrentFaction.MessageLog.Add(NMsg);
}
}
if (active == true)
{
activeTick = tick;
Contact = String.Format("{0} TCS {1} x{2}", Contact, (int)Math.Ceiling(DetectedMissileGroup.missiles[0].missileDef.size), DetectedMissileGroup.missiles.Count);
}
/// <summary>
/// print to the message log.
/// </summary>
NMsg = new MessageEntry(MessageEntry.MessageType.ContactNew, DetectedMissileGroup.contact.Position.System, DetectedMissileGroup.contact,
GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Contact);
CurrentFaction.MessageLog.Add(NMsg);
/// <summary>
/// Inform SimEntity.
/// </summary>
GameState.SE.SetInterrupt(InterruptType.NewSensorContact);
}
