/// <summary> /// Any special functionality needed for removing missiles. /// </summary> /// <param name="Missile">Missile to be removed</param> public void RemoveMissile(OrdnanceTN Missile) { Missiles.Remove(Missile); }
/// <summary> /// Constructor for missile groups. /// </summary> /// <param name="LaunchedFrom">TG this launched from. additional missiles may be added this tick but afterwards no more.</param> /// <param name="Missile">Initial missile that prompted the creation of this ordnance group.</param> /// <param name="MissileTarget">The target this group is aimed at.</param> public OrdnanceGroupTN(TaskGroupTN LaunchedFrom, OrdnanceTN Missile) { Name = String.Format("Ordnance Group #{0}", LaunchedFrom.TaskGroupFaction.MissileGroups.Count); Id = Guid.NewGuid(); if (LaunchedFrom.IsOrbiting == true) { LaunchedFrom.GetPositionFromOrbit(); } SSEntity = StarSystemEntityType.Missile; Position.X = LaunchedFrom.Contact.Position.X; Position.Y = LaunchedFrom.Contact.Position.Y; Contact = new SystemContact(LaunchedFrom.TaskGroupFaction, this); Missiles = new BindingList<OrdnanceTN>(); /// <summary> /// Missile Detection Statistics: /// This is the first missile so created, so it is in spot 0. /// </summary> Missile.ThermalDetection = new BindingList<int>(); Missile.EMDetection = new BindingList<int>(); Missile.ActiveDetection = new BindingList<int>(); for (int loop = 0; loop < Constants.Faction.FactionMax; loop++) { Missile.ThermalDetection.Add(GameState.Instance.CurrentSecond); Missile.EMDetection.Add(GameState.Instance.CurrentSecond); Missile.ActiveDetection.Add(GameState.Instance.CurrentSecond); } OrdnanceGroupFaction = LaunchedFrom.TaskGroupFaction; Contact.Position.System = LaunchedFrom.Contact.Position.System; LaunchedFrom.Position.System.SystemContactList.Add(Contact); DrawTravelLine = 0; ShipsTargetting = new BindingList<ShipTN>(); Missiles.Add(Missile); Missile.missileGroup = this; MissilesDestroyed = 0; OrdGroupsTargetting = new BindingList<OrdnanceGroupTN>(); /// <summary> /// Tell the sensor contact element to determine what if any sensors should be displayed. /// </summary> _SensorUpdateAck = 1; }
/// <summary> /// Adds a missile to the ordnance group. /// </summary> /// <param name="Missile">Missile to add, think of this as the ShipTN to OrdnanceGroupTN's TaskGroupTN</param> public void AddMissile(OrdnanceTN Missile) { /// <summary> /// Missile Detection Statistics: /// This is the first missile so created, so it is in spot 0. /// </summary> Missile.ThermalDetection = new BindingList<int>(); Missile.EMDetection = new BindingList<int>(); Missile.ActiveDetection = new BindingList<int>(); for (int loop = 0; loop < Constants.Faction.FactionMax; loop++) { Missile.ThermalDetection.Add(GameState.Instance.CurrentSecond); Missile.EMDetection.Add(GameState.Instance.CurrentSecond); Missile.ActiveDetection.Add(GameState.Instance.CurrentSecond); } Missiles.Add(Missile); Missile.missileGroup = this; }
/// <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> /// 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> /// This function calculates whether a given BFC can intercept a missile /// </summary> /// <param name="RNG">RNG to use, should be the global one in _SE_</param> /// <param name="IncrementDistance">Range to the target missile</param> /// <param name="Ordnance">Ordnance we want to shoot at.</param> /// <param name="ShipFaction">Faction of the ship this BFC is on.</param> /// <param name="Contact">Contact of the taskgroup this BFC is in.</param> /// <param name="ShipOn">Ship this BFC is on.</param> /// <param name="WeaponsFired">Whether or not a weapon was fired. this is for the recharge list further up</param> /// <returns>whether the missile was intercepted.</returns> public bool InterceptTarget(Random RNG, int IncrementDistance, OrdnanceTN Ordnance, Faction ShipFaction, SystemContact Contact, ShipTN ShipOn, out bool WeaponsFired) { WeaponsFired = false; float ShipSpeed = ShipOn.CurrentSpeed; float track = (float)ShipFaction.BaseTracking; if (ShipSpeed > track) track = ShipSpeed; if (m_oBeamFireControlDef.tracking < track) track = m_oBeamFireControlDef.tracking; /// <summary> /// Throwaway target for point defense purposes. /// </summary> TargetTN OverrideTarget = new TargetTN(Ordnance.missileGroup); float Acc = GetFiringAccuracy(IncrementDistance, (int)track, OverrideTarget); int toHit = (int)Math.Floor(Acc * 100.0f); int range = (IncrementDistance + 1) * 10000; String Range = range.ToString("#,###0"); foreach (BeamTN LinkedWeapon in m_lLinkedWeapons) { /// <summary> /// Certain weapons will have already fired one or more of their shots, but may still have more available. /// </summary> bool AcceptPartialFire = (LinkedWeapon.beamDef.componentType == ComponentTypeTN.Rail || LinkedWeapon.beamDef.componentType == ComponentTypeTN.AdvRail || LinkedWeapon.beamDef.componentType == ComponentTypeTN.Gauss) && (LinkedWeapon.shotsExpended < LinkedWeapon.beamDef.shotCount); if (LinkedWeapon.readyToFire() == true || AcceptPartialFire == true) { if (LinkedWeapon.beamDef.componentType == ComponentTypeTN.Rail || LinkedWeapon.beamDef.componentType == ComponentTypeTN.AdvRail || LinkedWeapon.beamDef.componentType == ComponentTypeTN.Gauss) { WeaponsFired = LinkedWeapon.Fire(); /// <summary> /// multi-hit weapons will be a little wierd as far as PD goes. /// </summary> if (WeaponsFired == false && AcceptPartialFire == true) WeaponsFired = true; int expended = LinkedWeapon.shotsExpended; int ShotCount = LinkedWeapon.beamDef.shotCount; for (int BeamShotIterator = expended; BeamShotIterator < ShotCount; BeamShotIterator++) { ushort Hit = (ushort)RNG.Next(1, 100); LinkedWeapon.shotsExpended++; if (toHit >= Hit) { String Entry = String.Format("{0} Fired at {1} km and hit.", LinkedWeapon.Name, Range); MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.FiringHit, Contact.Position.System, Contact, GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Entry); ShipFaction.MessageLog.Add(Msg); return true; } else { String Entry = String.Format("{0} Fired at {1} km and missed.", LinkedWeapon.Name, Range); MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.FiringHit, Contact.Position.System, Contact, GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Entry); ShipFaction.MessageLog.Add(Msg); } } } else { ushort Hit = (ushort)RNG.Next(1, 100); WeaponsFired = LinkedWeapon.Fire(); if (toHit >= Hit) { String Entry = String.Format("{0} Fired at {1} km and hit.", LinkedWeapon.Name, Range); MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.FiringHit, Contact.Position.System, Contact, GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Entry); ShipFaction.MessageLog.Add(Msg); return true; } else { String Entry = String.Format("{0} Fired at {1} km and missed.", LinkedWeapon.Name, Range); MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.FiringHit, Contact.Position.System, Contact, GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Entry); ShipFaction.MessageLog.Add(Msg); } } } } foreach (TurretTN LinkedTurret in m_lLinkedTurrets) { /// <summary> /// Double, triple, and quad turrets have multiple shots. /// </summary> bool AcceptPartialFire = (LinkedTurret.shotsExpended < LinkedTurret.turretDef.totalShotCount); if (LinkedTurret.readyToFire() == true || AcceptPartialFire == true) { WeaponsFired = LinkedTurret.Fire(); /// <summary> /// multi-hit weapons will be a little wierd as far as PD goes. /// </summary> if (WeaponsFired == false && AcceptPartialFire == true) WeaponsFired = true; int expended = LinkedTurret.shotsExpended; int ShotCount = LinkedTurret.turretDef.totalShotCount; for (int TurretShotIterator = expended; TurretShotIterator < ShotCount; TurretShotIterator++) { ushort Hit = (ushort)RNG.Next(1, 100); LinkedTurret.shotsExpended++; if (toHit >= Hit) { String Entry = String.Format("{0} Fired at {1} km and hit.", LinkedTurret.Name, Range); MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.FiringHit, Contact.Position.System, Contact, GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Entry); ShipFaction.MessageLog.Add(Msg); return true; } else { String Entry = String.Format("{0} Fired at {1} km and missed.", LinkedTurret.Name, Range); MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.FiringHit, Contact.Position.System, Contact, GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Entry); ShipFaction.MessageLog.Add(Msg); } } } } return false; }
/// <summary> /// Final defensive fire scans through all potential FCs that could fire defensively on the incoming missile to see if it is intercepeted. /// All PD enabled FCs will attempt to shoot down this missile except ones from the same faction, as this missile is practically right on top of said FC. /// In other words allied/neutral status isn't taken into account. /// </summary> /// <param name="P">Faction list</param> /// <param name="Missile">Missile to try to intercept</param> /// <param name="RNG">Random Number Generator</param> /// <returns>Whether the missile has been intercepted</returns> public static bool FinalDefensiveFire(BindingList<Faction> P, OrdnanceTN Missile, Random RNG) { bool Intercept = false; StarSystem CurrentSystem = Missile.missileGroup.contact.Position.System; float PointBlank = (float)Distance.ToAU(10000.0); /// <summary> /// loop through every faction. /// </summary> foreach (Faction faction in P) { /// <summary> /// Is the current faction different from the missile group faction, and does the faction have a detected contacts list for the current system? /// </summary> if (faction != Missile.missileGroup.ordnanceGroupFaction && faction.DetectedContactLists.ContainsKey(CurrentSystem) == true) { /// <summary> /// Is the Missile group in this detected contact list? /// </summary> if (faction.DetectedContactLists[CurrentSystem].DetectedMissileContacts.ContainsKey(Missile.missileGroup) == true) { /// <summary> /// Is the detection an active detection? /// </summary> if (faction.DetectedContactLists[CurrentSystem].DetectedMissileContacts[Missile.missileGroup].active == true) { /// <summary> /// Does this faction have any point defense enabled FCs in this system? /// </summary> if (faction.PointDefense.ContainsKey(CurrentSystem) == true) { /// <summary> /// loop through all the possible PD enabled FC. /// </summary> foreach (KeyValuePair<ComponentTN, ShipTN> pair in faction.PointDefense[CurrentSystem].PointDefenseFC) { ShipTN Ship = pair.Value; /// <summary> /// Ship jump sickness will prevent point defense from operating. /// </summary> if (Ship.IsJumpSick()) continue; /// <summary> /// Only want BFCs in FDF mode for now. /// </summary> if (faction.PointDefense[CurrentSystem].PointDefenseType[pair.Key] == false && pair.Value.ShipBFC[pair.Key.componentIndex].pDState == PointDefenseState.FinalDefensiveFire) { BeamFireControlTN ShipBeamFC = pair.Value.ShipBFC[pair.Key.componentIndex]; /// <summary> /// Do a distance check on pair.Value vs the missile itself. if that checks out to be less than 10k km(or equal to zero), then /// check to see if the FC can shoot down said missile. This should never be run before a sensor sweep /// </summary> float dist = -1; /// <summary> /// dist is in AU. /// </summary> Missile.missileGroup.contact.DistTable.GetDistance(Ship.ShipsTaskGroup.Contact, out dist); /// <summary> /// if distance is less than the 10k km threshold attempt to intercept at Point blank range. /// </summary> if (dist < PointBlank) { /// <summary> /// Finally intercept the target. /// </summary> bool WF = false; Intercept = ShipBeamFC.InterceptTarget(RNG, 0, Missile, Ship.ShipsFaction, Ship.ShipsTaskGroup.Contact, Ship, out WF); /// <summary> /// Add this ship to the weapon recharge list since it has fired. This is done here in Sim, or for FDF_Self in Ship.cs /// </summary> if (WF == true) { if (faction.RechargeList.ContainsKey(Ship) == true) { /// <summary> /// If our recharge value does not have Recharge beams in it(bitflag 2 for now), then add it. /// </summary> if ((faction.RechargeList[pair.Value] & (int)Faction.RechargeStatus.Weapons) != (int)Faction.RechargeStatus.Weapons) { faction.RechargeList[pair.Value] = (faction.RechargeList[pair.Value] + (int)Faction.RechargeStatus.Weapons); } } else { faction.RechargeList.Add(pair.Value, (int)Faction.RechargeStatus.Weapons); } } /// <summary> /// break out of the first foreach loop. /// </summary> if (Intercept == true) break; } } } } } } } /// <summary> /// now break out of the faction loop as this missile has been shot down. /// </summary> if (Intercept == true) break; } return Intercept; }
/// <summary> /// InterceptMissile tests to see whether a CIWS on this ship can shoot down an incoming missile or not. /// </summary> /// <param name="RNG">Should be a global RNG</param> /// <param name="MissileSpeed">Speed of incoming missile.</param> /// <returns>Whether or not intercept happened</returns> public bool InterceptMissile(Random RNG, OrdnanceTN Ordnance) { /// <summary> /// Can we perform this action or will jump sickness interfere? /// </summary> if (IsJumpSick()) return false; /// <summary> /// Personal Point defense(CIWS/FDF(Self)/FDF) here /// </summary> /// <summary> /// If this ship has CIWS, they are about to be fired, so add this ship to the faction recharge list. /// </summary> if (ShipCIWS.Count != 0) { if (ShipsFaction.RechargeList.ContainsKey(this) == true) { /// <summary> /// If our recharge value does not have CIWS in it(bitflag 8 for now), then add it. /// </summary> if ((ShipsFaction.RechargeList[this] & (int)Faction.RechargeStatus.CIWS) != (int)Faction.RechargeStatus.CIWS) { ShipsFaction.RechargeList[this] = (ShipsFaction.RechargeList[this] + (int)Faction.RechargeStatus.CIWS); } } else { ShipsFaction.RechargeList.Add(this, (int)Faction.RechargeStatus.CIWS); } } bool Intercept = false; for (int loop2 = ShipCIWSIndex; loop2 < ShipCIWS.Count; loop2++) { Intercept = ShipCIWS[loop2].InterceptTarget(RNG, Ordnance.missileDef.maxSpeed, ShipsFaction, ShipsTaskGroup.Contact); if (Intercept == true) { ShipCIWSIndex = loop2; return true; } } if (Intercept == false) { for (int loop2 = 0; loop2 < ShipBFC.Count; loop2++) { if (ShipBFC[loop2].pDState == PointDefenseState.FinalDefensiveFireSelf) { /// <summary> /// Now I need to know whether the beam weapons linked to this PD can fire. for regular beams that is simple enough. /// everything capable of multifire on the other hand is another matter. Gauss, railguns, and turrets will all have multiple shots, and they have to be /// given the opportunity to use those shots against different missiles. I could do a similar thing to ShipCIWSIndex for BFCs but will refrain from doing so for the moment. /// </summary> bool WF = false; Intercept = ShipBFC[loop2].InterceptTarget(RNG, 0, Ordnance, ShipsFaction, ShipsTaskGroup.Contact, this, out WF); if (WF == true) { if (ShipsFaction.RechargeList.ContainsKey(this) == true) { /// <summary> /// If our recharge value does not have Recharge beams in it(bitflag 2 for now), then add it. /// </summary> if ((ShipsFaction.RechargeList[this] & (int)Faction.RechargeStatus.Weapons) != (int)Faction.RechargeStatus.Weapons) { ShipsFaction.RechargeList[this] = (ShipsFaction.RechargeList[this] + (int)Faction.RechargeStatus.Weapons); } } else { ShipsFaction.RechargeList.Add(this, (int)Faction.RechargeStatus.Weapons); } } if (Intercept == true) { return true; } } } } return false; }