public void testArmor() { Faction newFaction = new Faction(0); ShipClassTN ts2 = new ShipClassTN("Test", newFaction); StarSystem System1 = SystemGen.CreateSol(); SystemBody pl1 = new SystemBody(System1.Stars[0], SystemBody.PlanetType.Terrestrial); System1.Stars[0].Planets.Add(pl1); TaskGroupTN newTG = new TaskGroupTN("TG", newFaction, System1.Stars[0].Planets[0], System1); ShipTN ts = new ShipTN(ts2, 0, 0, newTG, newFaction, "Test Ship"); ts2.ShipArmorDef = new ArmorDefTN("Duranium Armour"); ts.ShipArmor = new ArmorTN(ts2.ShipArmorDef); ts2.ShipArmorDef.CalcArmor("Duranium Armor", 5, 38.0, 5); Console.WriteLine("ArmorPerHS: {0}", ts2.ShipArmorDef.armorPerHS); Console.WriteLine("Size: {0}", ts2.ShipArmorDef.size); Console.WriteLine("Cost: {0}", ts2.ShipArmorDef.cost); Console.WriteLine("Area: {0}", ts2.ShipArmorDef.area); Console.WriteLine("Depth: {0}", ts2.ShipArmorDef.depth); Console.WriteLine("Column Number: {0}", ts2.ShipArmorDef.cNum); Console.WriteLine("isDamaged: {0}", ts.ShipArmor.isDamaged); ts.ShipArmor.SetDamage(ts2.ShipArmorDef.cNum, ts2.ShipArmorDef.depth, 4, 1); for (int loop = 0; loop < ts2.ShipArmorDef.cNum; loop++) { Console.WriteLine("Column Value: {0}", ts.ShipArmor.armorColumns[loop]); } Console.WriteLine("Damage Key: {0}, Column Value: {1}", ts.ShipArmor.armorDamage.Min().Key, ts.ShipArmor.armorDamage.Min().Value); Console.WriteLine("isDamaged: {0}", ts.ShipArmor.isDamaged); ts.ShipArmor.RepairSingleBlock(ts2.ShipArmorDef.depth); Console.WriteLine("isDamaged: {0}", ts.ShipArmor.isDamaged); ts.ShipArmor.SetDamage(ts2.ShipArmorDef.cNum, ts2.ShipArmorDef.depth, 4, 1); for (int loop = 0; loop < ts2.ShipArmorDef.cNum; loop++) { Console.WriteLine("Column Value: {0}", ts.ShipArmor.armorColumns[loop]); } Console.WriteLine("Damage Key: {0}, Column Value: {1}", ts.ShipArmor.armorDamage.Min().Key, ts.ShipArmor.armorDamage.Min().Value); Console.WriteLine("isDamaged: {0}", ts.ShipArmor.isDamaged); ts.ShipArmor.RepairAllArmor(); Console.WriteLine("isDamaged: {0}", ts.ShipArmor.isDamaged); Console.WriteLine("Cost: {0}, Area: {1},Size: {2}", ts.ShipArmor.armorDef.cost, ts.ShipArmor.armorDef.area, ts.ShipArmor.armorDef.size); }
/// <summary> /// Constructor for TGViewModel. Initialization is to faction 0 task group 0. /// Later functionality will handle updating faction and taskgroup indices. /// </summary> public TaskGroupViewModel() { _CurrentFaction = GameState.Instance.Factions[0]; Factions = GameState.Instance.Factions; if (GameState.Instance.Factions[0].TaskGroups.Count != 0) _CurrentTaskGroup = GameState.Instance.Factions[0].TaskGroups[0]; TaskGroups = GameState.Instance.Factions[0].TaskGroups; }
private void OnFactionChanged() { TaskGroups = GameState.Instance.Factions[_CurrentFaction.FactionID].TaskGroups; if (TaskGroups.Count != 0) _CurrentTaskGroup = TaskGroups[0]; if (FactionChanged != null) { FactionChanged(this, new EventArgs()); } }
public void testPSensor() { Faction newFaction = new Faction(0); StarSystem System1 = SystemGen.CreateSol(); SystemBody pl1 = new SystemBody(System1.Stars[0], SystemBody.PlanetType.Terrestrial); System1.Stars[0].Planets.Add(pl1); TaskGroupTN newTG = new TaskGroupTN("TG", newFaction, System1.Stars[0].Planets[0], System1); ShipClassTN ts2 = new ShipClassTN("Test", newFaction); ShipTN ts = new ShipTN(ts2, 0, 0, newTG, newFaction, "Test Ship"); PassiveSensorDefTN PSensorDefTest = new PassiveSensorDefTN("Thermal Sensor TH19-342", 19.0f, 18, PassiveSensorType.Thermal, 1.0f, 1); ts2.ShipPSensorDef = new BindingList<PassiveSensorDefTN>(); ts2.ShipPSensorCount = new BindingList<ushort>(); ts2.ShipPSensorDef.Add(PSensorDefTest); ts2.ShipPSensorCount.Add(1); PassiveSensorTN PSensorTest = new PassiveSensorTN(ts2.ShipPSensorDef[0]); ts.ShipPSensor = new BindingList<PassiveSensorTN>(); ts.ShipPSensor.Add(PSensorTest); PassiveSensorDefTN tst3 = ts.ShipPSensor[0].pSensorDef; Console.WriteLine("Name: {0}", tst3.Name); Console.WriteLine("Size: {0}, HTK: {1}, Hardening: {2}", tst3.size, tst3.htk, tst3.hardening); Console.WriteLine("Rating: {0}, Range: {1}", tst3.rating, tst3.range); Console.WriteLine("IsMilitary: {0}", tst3.isMilitary); Console.WriteLine("Crew: {0}", tst3.crew); Console.WriteLine("Cost: {0}", tst3.cost); for (ushort loop = 80; loop < 120; loop++) { Console.WriteLine("Signature:{0} Detection Range in KM:{1}", loop, tst3.GetPassiveDetectionRange(loop)); } }
public void testEngine() { Faction newFaction = new Faction(0); StarSystem System1 = SystemGen.CreateSol(); SystemBody pl1 = new SystemBody(System1.Stars[0], SystemBody.PlanetType.Terrestrial); System1.Stars[0].Planets.Add(pl1); TaskGroupTN newTG = new TaskGroupTN("TG", newFaction, System1.Stars[0].Planets[0], System1); ShipClassTN ts2 = new ShipClassTN("Test", newFaction); ShipTN ts = new ShipTN(ts2, 0, 0, newTG, newFaction, "Test Ship"); ts2.ShipEngineDef = new EngineDefTN("3137.6 EP Inertial Fusion Drive", 32, 2.65f, 0.6f, 0.75f, 2, 37, -1.0f); ts2.ShipEngineCount = 1; EngineTN temp = new EngineTN(ts2.ShipEngineDef); ts.ShipEngine = new BindingList<EngineTN>(); ts.ShipEngine.Add(temp); EngineDefTN tst = ts.ShipEngine[0].engineDef; Console.WriteLine("Name: {0}", tst.Name); Console.WriteLine("EngineBase: {0}, PowerMod: {1}, FuelConMod: {2}, ThermalReduction: {3}, Size: {4},HyperMod: {5}", tst.engineBase, tst.powerMod, tst.fuelConsumptionMod, tst.thermalReduction, tst.size, tst.hyperDriveMod); Console.WriteLine("EnginePower: {0}, FuelUsePerHour: {1}", tst.enginePower, tst.fuelUsePerHour); Console.WriteLine("EngineSize: {0}, EngineHTK: {1}", tst.size, tst.htk); Console.WriteLine("ThermalSignature: {0}, ExpRisk: {1}", tst.thermalSignature, tst.expRisk); Console.WriteLine("IsMilitary: {0}", tst.isMilitary); Console.WriteLine("Crew: {0}", tst.crew); Console.WriteLine("Cost: {0}", tst.cost); }
/// <summary> /// Constructor for task. /// ABR = Normal shipbuilding rate x (1+(((Class Size / 100) - 1)/2)) /// Scrap Formula is ((0.25 * ShipCost) / ABR) * Year = days involved. /// </summary> /// <param name="Ship">Ship to repair/refit/scrap. build will be handled elsewhere.</param> /// <param name="TargetTG">Target TG which the ship will be put back in to, or in the case of a scrap operation taken from.</param> /// <param name="PopulationBuildRate">What is the currently selected shipyard capable of building? population and faction should factor into this number.</param> /// <param name="ConstructOrRefitTarget">If a new ship is being built, or an old ship is being refitted, what target design are we interested in?</param> public ShipyardTask(ShipTN Ship, Constants.ShipyardInfo.Task TaskToPerform, TaskGroupTN TargetTG, int PopulationBuildRate, String TitleToUse, ShipClassTN ConstructOrRefitTarget=null) { m_aiMinerialsCost = new decimal[(int)Constants.Minerals.MinerialNames.MinerialCount]; CurrentShip = Ship; CurrentTask = TaskToPerform; Progress = 0.0m; Priority = 0; Paused = false; ConstructRefitTarget = ConstructOrRefitTarget; ABR = 1; AssignedTaskGroup = TargetTG; if(AssignedTaskGroup != null) AssignedTaskGroup.IsInShipyard = true; Cost = 0.0m; /// <summary> /// This is only relevant for new ship construction. /// </summary> Title = TitleToUse; switch (TaskToPerform) { case Constants.ShipyardInfo.Task.Construction: ABR = (int)Math.Round(PopulationBuildRate * (1.0f + (((ConstructRefitTarget.SizeHS / 100.0f) - 1.0f) / 2.0f))); Cost = ConstructRefitTarget.BuildPointCost; for (int mineralIterator = 0; mineralIterator < (int)Constants.Minerals.MinerialNames.MinerialCount; mineralIterator++) { m_aiMinerialsCost[mineralIterator] = ConstructRefitTarget.minerialsCost[mineralIterator]; } break; case Constants.ShipyardInfo.Task.Repair: ABR = (int)Math.Round(PopulationBuildRate * (1.0f + (((Ship.ShipClass.SizeHS / 100.0f) - 1.0f) / 2.0f))); /// <summary> /// Repair will just cost money. Two reasons. 1st: Laziness. I'd have to get all the component costs as well. /// 2nd:Ships require continuous resource outlays via routine maintenance, that should and will cover the actual cost of repairing the ship above and beyond the money required. /// </summary> for(int componentIterator = 0; componentIterator < Ship.DestroyedComponents.Count; componentIterator++) { ushort ID = Ship.DestroyedComponents[componentIterator]; ComponentTypeTN CType = Ship.DestroyedComponentsType[componentIterator]; Cost = Cost + Ship.GetDamagedComponentsRepairCost(ID,CType); } if(Ship.ShipArmor.isDamaged == true) { int totalDamage = 0; int max = Ship.ShipArmor.armorDef.cNum * Ship.ShipArmor.armorDef.depth; foreach (KeyValuePair<ushort, ushort> pair in Ship.ShipArmor.armorDamage) { totalDamage = totalDamage + pair.Value; } float damageFraction = ((float)totalDamage / (float)max); Cost = Cost + ((decimal)damageFraction * Ship.ShipArmor.armorDef.cost); } for (int mineralIterator = 0; mineralIterator < (int)Constants.Minerals.MinerialNames.MinerialCount; mineralIterator++) { m_aiMinerialsCost[mineralIterator] = 0.0m; } break; case Constants.ShipyardInfo.Task.Refit: ABR = (int)Math.Round(PopulationBuildRate * (1.0f + (((ConstructRefitTarget.SizeHS / 100.0f) - 1.0f) / 2.0f))); Cost = ConstructRefitTarget.BuildPointCost; for (int mineralIterator = 0; mineralIterator < (int)Constants.Minerals.MinerialNames.MinerialCount; mineralIterator++) { m_aiMinerialsCost[mineralIterator] = ConstructRefitTarget.minerialsCost[mineralIterator]; } break; case Constants.ShipyardInfo.Task.Scrap: ABR = (int)Math.Round(PopulationBuildRate * (1.0f + (((Ship.ShipClass.SizeHS / 100.0f) - 1.0f) / 2.0f))); Cost = Ship.ShipClass.BuildPointCost * -0.25m; for (int mineralIterator = 0; mineralIterator < (int)Constants.Minerals.MinerialNames.MinerialCount; mineralIterator++) { m_aiMinerialsCost[mineralIterator] = Ship.ShipClass.minerialsCost[mineralIterator] * -0.25m; } break; } /// <summary> /// How long will this retool take? /// </summary> float DaysInYear = (float)Constants.TimeInSeconds.RealYear / (float)Constants.TimeInSeconds.Day; float YearsOfProduction = (float)Math.Abs(Cost) / (float)ABR; DateTime EstTime = GameState.Instance.GameDateTime; if (YearsOfProduction < Constants.Colony.TimerYearMax) { int TimeToBuild = (int)Math.Floor(YearsOfProduction * DaysInYear); TimeSpan TS = new TimeSpan(TimeToBuild, 0, 0, 0); EstTime = EstTime.Add(TS); } CompletionDate = EstTime; }
/// <summary> /// ShipTN creates a ship of classDefinition in Index ShipIndex for the taskgroup ship list. /// </summary> /// <param name="ClassDefinition">Definition of the ship.</param> /// <param name="ShipIndex">Its index within the shiplist of the taskgroup.</param> /// <param name="CurrentTimeSlice">tick when this ship is created.</param> /// <param name="ShipTG">TG this ship belongs to.</param> /// <param name="ShipFact">Faction this ship belongs to.</param> /// <param name="Title">Name of the ship.</param> public ShipTN(ShipClassTN ClassDefinition, int ShipIndex, int CurrentTimeSlice, TaskGroupTN ShipTG, Faction ShipFact, String Title) { int index; Name = Title; /// <summary> /// create these or else anything that relies on a unique global id will break. /// </summary> Id = Guid.NewGuid(); /// <summary> /// Set the class definition /// </summary> ShipClass = ClassDefinition; /// <summary> /// Inform the class that it has a new member. /// </summary> ClassDefinition.ShipsInClass.Add(this); /// <summary> /// Ships are standard crewed vessels for now. /// </summary> TypeOf = ShipType.Standard; /// <summary> /// Tell the Ship which TG it is a part of. /// </summary> ShipsTaskGroup = ShipTG; /// <summary> /// Likewise for Faction. /// </summary> ShipsFaction = ShipFact; /// <summary> /// Add this ship to the overall faction ship list. /// </summary> ShipsFaction.Ships.Add(this); /// <summary> /// Make sure to initialize this important variable that everything uses. /// </summary> ShipComponents = new BindingList<ComponentTN>(); /// <summary> /// Initialize the list of Ship fire controls. /// </summary> ShipFireControls = new BindingList<ComponentTN>(); /// <summary> /// Likewise the ListOfComponentDefs counterpart here is important. /// </summary> ComponentDefIndex = new BindingList<ushort>(); for (int loop = 0; loop < ClassDefinition.ListOfComponentDefs.Count; loop++) { ComponentDefIndex.Add(0); } /// <summary> /// List of components that have been destroyed. /// </summary> DestroyedComponents = new BindingList<ushort>(); DestroyedComponentsType = new BindingList<ComponentTypeTN>(); /// <summary> /// How much damage can the ship take? /// </summary> ShipHTK = ShipClass.TotalHTK; /// <summary> /// When the destroyed components list is populated it can be selected from to put components here to be repaired. /// </summary> DamageControlQue = new BindingList<ushort>(); /// <summary> /// Not yet set. /// </summary> DamageControlTarget = -1; /// <summary> /// All ships will have armor, and all ship defs should have armor before this point. /// </summary. ShipArmor = new ArmorTN(ClassDefinition.ShipArmorDef); /// <summary> /// Crew Quarters don't strictly have to be present, but will be in almost all designs. /// </summary> CrewQuarters = new BindingList<GeneralComponentTN>(); AddComponents(CrewQuarters, ClassDefinition.CrewQuarters, ClassDefinition.CrewQuartersCount); /// <summary> /// Subtract crew from crew pool if ship is not conscript staffed Here: /// </summary> CurrentCrew = 0; SpareBerths = ShipClass.TotalCrewQuarters; CurrentCryoStorage = 0; CurrentDeployment = 0.0f; Morale = 100.0f; ShipGrade = 0.0f; TFTraining = 0.0f; /// <summary> ///Fuel Tanks don't have to be present, but will be in most designs. /// </summary> FuelTanks = new BindingList<GeneralComponentTN>(); AddComponents(FuelTanks, ClassDefinition.FuelTanks, ClassDefinition.FuelTanksCount); CurrentFuel = 0.0f; CurrentFuelCapacity = ShipClass.TotalFuelCapacity; FuelCounter = 0; /// <summary> /// Engineering spaces must be on civ designs(atleast 1), but can be absent from military designs. /// </summary> EngineeringBays = new BindingList<GeneralComponentTN>(); AddComponents(EngineeringBays, ClassDefinition.EngineeringBays, ClassDefinition.EngineeringBaysCount); CurrentDamageControlRating = ClassDefinition.MaxDamageControlRating; CurrentMSP = ShipClass.TotalMSPCapacity; CurrentMSPCapacity = ShipClass.TotalMSPCapacity; MaintenanceClock = 0.0f; /// <summary> /// All remaining components that are of a more specialized nature. These do not have to be present, except bridges on ships bigger than 1K tons. /// </summary> OtherComponents = new BindingList<GeneralComponentTN>(); AddComponents(OtherComponents, ClassDefinition.OtherComponents, ClassDefinition.OtherComponentsCount); /// <summary> /// All mobile ships need engines, orbitals and PDCs don't however. /// </summary> ShipEngine = new BindingList<EngineTN>(); index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipEngineDef); if (index != -1) ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop = 0; loop < ClassDefinition.ShipEngineCount; loop++) { EngineTN Engine = new EngineTN(ClassDefinition.ShipEngineDef); Engine.componentIndex = ShipEngine.Count; ShipEngine.Add(Engine); ShipComponents.Add(Engine); } CurrentEnginePower = ClassDefinition.MaxEnginePower; CurrentMaxEnginePower = CurrentEnginePower; CurrentThermalSignature = ClassDefinition.MaxThermalSignature; CurrentMaxThermalSignature = CurrentThermalSignature; CurrentSpeed = ClassDefinition.MaxSpeed; CurrentMaxSpeed = CurrentSpeed; CurrentFuelUsePerHour = ClassDefinition.MaxFuelUsePerHour; CurrentMaxFuelUsePerHour = CurrentFuelUsePerHour; /// <summary> /// Usually only cargo ships and salvagers will have cargo holds. /// </summary> ShipCargo = new BindingList<CargoTN>(); for (int loop = 0; loop < ClassDefinition.ShipCargoDef.Count; loop++) { index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipCargoDef[loop]); ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop2 = 0; loop2 < ClassDefinition.ShipCargoCount[loop]; loop2++) { CargoTN cargo = new CargoTN(ClassDefinition.ShipCargoDef[loop]); cargo.componentIndex = ShipCargo.Count; ShipCargo.Add(cargo); ShipComponents.Add(cargo); } } CurrentCargoTonnage = 0; CargoList = new Dictionary<Installation.InstallationType, CargoListEntryTN>(); CargoComponentList = new Dictionary<ComponentDefTN, CargoListEntryTN>(); /// <summary> /// While only colonyships will have the major bays, just about any craft can have an emergency cryo bay. /// </summary> ShipColony = new BindingList<ColonyTN>(); for (int loop = 0; loop < ClassDefinition.ShipColonyDef.Count; loop++) { index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipColonyDef[loop]); ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop2 = 0; loop2 < ClassDefinition.ShipColonyCount[loop]; loop2++) { ColonyTN colony = new ColonyTN(ClassDefinition.ShipColonyDef[loop]); colony.componentIndex = ShipColony.Count; ShipColony.Add(colony); ShipComponents.Add(colony); } } CurrentCryoStorage = 0; /// <summary> /// Any ship with cargo holds, troop bays, cryo berths, or drop pods will benefit from a cargohandling system. though droppods benefit from the CHSes on other vessels as well. /// </summary> ShipCHS = new BindingList<CargoHandlingTN>(); for (int loop = 0; loop < ClassDefinition.ShipCHSDef.Count; loop++) { index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipCHSDef[loop]); ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop2 = 0; loop2 < ClassDefinition.ShipCHSCount[loop]; loop2++) { CargoHandlingTN CHS = new CargoHandlingTN(ClassDefinition.ShipCHSDef[loop]); CHS.componentIndex = ShipCHS.Count; ShipCHS.Add(CHS); ShipComponents.Add(CHS); } } CurrentTractorMultiplier = ShipClass.TractorMultiplier; /// <summary> /// Every ship will have a passive sensor rating, but very few will have specialized passive sensors. /// </summary> ShipPSensor = new BindingList<PassiveSensorTN>(); for (int loop = 0; loop < ClassDefinition.ShipPSensorDef.Count; loop++) { index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipPSensorDef[loop]); ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop2 = 0; loop2 < ClassDefinition.ShipPSensorCount[loop]; loop2++) { PassiveSensorTN PSensor = new PassiveSensorTN(ClassDefinition.ShipPSensorDef[loop]); PSensor.componentIndex = ShipPSensor.Count; ShipPSensor.Add(PSensor); ShipComponents.Add(PSensor); } } /// <summary> /// These two can and will change if the ship takes damage to its sensors. /// </summary> BestThermalRating = ClassDefinition.BestThermalRating; BestEMRating = ClassDefinition.BestEMRating; /// <summary> /// Active Sensors will be probably rarer than passive sensors, as they betray their location to any listener in range. /// And the listener may be far enough away that the active will not ping him. /// </summary> ShipASensor = new BindingList<ActiveSensorTN>(); for (int loop = 0; loop < ClassDefinition.ShipASensorDef.Count; loop++) { index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipASensorDef[loop]); ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop2 = 0; loop2 < ClassDefinition.ShipASensorCount[loop]; loop2++) { ActiveSensorTN ASensor = new ActiveSensorTN(ClassDefinition.ShipASensorDef[loop]); ASensor.componentIndex = ShipASensor.Count; int ASIndex = loop2 + 1; ASensor.Name = ASensor.aSensorDef.Name + " #" + ASIndex.ToString(); ShipASensor.Add(ASensor); ShipComponents.Add(ASensor); } } /// <summary> /// This won't change, but it should be here for convenience during sensor sweeps. /// </summary> TotalCrossSection = ClassDefinition.TotalCrossSection; CurrentEMSignature = 0; /// <summary> /// Detection Statistics initialization: /// </summary> ThermalList = new LinkedListNode<int>(ShipIndex); EMList = new LinkedListNode<int>(ShipIndex); ActiveList = new LinkedListNode<int>(ShipIndex); ThermalDetection = new BindingList<int>(); EMDetection = new BindingList<int>(); ActiveDetection = new BindingList<int>(); for (int loop = 0; loop < Constants.Faction.FactionMax; loop++) { ThermalDetection.Add(CurrentTimeSlice); EMDetection.Add(CurrentTimeSlice); ActiveDetection.Add(CurrentTimeSlice); } ShipCommanded = false; ShipBFC = new BindingList<BeamFireControlTN>(); for (int loop = 0; loop < ClassDefinition.ShipBFCDef.Count; loop++) { index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipBFCDef[loop]); ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop2 = 0; loop2 < ClassDefinition.ShipBFCCount[loop]; loop2++) { BeamFireControlTN BFC = new BeamFireControlTN(ClassDefinition.ShipBFCDef[loop]); BFC.componentIndex = ShipBFC.Count; int BFCIndex = loop2 + 1; BFC.Name = BFC.beamFireControlDef.Name + " #" + BFCIndex.ToString(); ShipBFC.Add(BFC); ShipComponents.Add(BFC); ShipFireControls.Add(BFC); } } ShipBeam = new BindingList<BeamTN>(); for (int loop = 0; loop < ClassDefinition.ShipBeamDef.Count; loop++) { index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipBeamDef[loop]); ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop2 = 0; loop2 < ClassDefinition.ShipBeamCount[loop]; loop2++) { BeamTN Beam = new BeamTN(ClassDefinition.ShipBeamDef[loop]); Beam.componentIndex = ShipBeam.Count; int BeamIndex = loop2 + 1; Beam.Name = Beam.beamDef.Name + " #" + BeamIndex.ToString(); ShipBeam.Add(Beam); ShipComponents.Add(Beam); } } ShipReactor = new BindingList<ReactorTN>(); for (int loop = 0; loop < ClassDefinition.ShipReactorDef.Count; loop++) { index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipReactorDef[loop]); ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop2 = 0; loop2 < ClassDefinition.ShipReactorCount[loop]; loop2++) { ReactorTN Reactor = new ReactorTN(ClassDefinition.ShipReactorDef[loop]); Reactor.componentIndex = ShipReactor.Count; ShipReactor.Add(Reactor); ShipComponents.Add(Reactor); } } CurrentPowerGen = ClassDefinition.TotalPowerGeneration; ShipShield = new BindingList<ShieldTN>(); index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipShieldDef); if (index != -1) ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop = 0; loop < ClassDefinition.ShipShieldCount; loop++) { ShieldTN Shield = new ShieldTN(ClassDefinition.ShipShieldDef); Shield.componentIndex = ShipShield.Count; ShipShield.Add(Shield); ShipComponents.Add(Shield); } CurrentShieldPool = 0.0f; CurrentShieldPoolMax = ClassDefinition.TotalShieldPool; CurrentShieldGen = ClassDefinition.TotalShieldGenPerTick; CurrentShieldFuelUse = ClassDefinition.TotalShieldFuelCostPerTick; ShieldIsActive = false; ShipMLaunchers = new BindingList<MissileLauncherTN>(); for (int loop = 0; loop < ClassDefinition.ShipMLaunchDef.Count; loop++) { index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipMLaunchDef[loop]); ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop2 = 0; loop2 < ClassDefinition.ShipMLaunchCount[loop]; loop2++) { MissileLauncherTN Tube = new MissileLauncherTN(ClassDefinition.ShipMLaunchDef[loop]); Tube.componentIndex = ShipMLaunchers.Count; int TubeIndex = loop2 + 1; Tube.Name = Tube.missileLauncherDef.Name + " #" + TubeIndex.ToString(); ShipMLaunchers.Add(Tube); ShipComponents.Add(Tube); } } ShipMagazines = new BindingList<MagazineTN>(); for (int loop = 0; loop < ClassDefinition.ShipMagazineDef.Count; loop++) { index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipMagazineDef[loop]); ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop2 = 0; loop2 < ClassDefinition.ShipMagazineCount[loop]; loop2++) { MagazineTN Mag = new MagazineTN(ClassDefinition.ShipMagazineDef[loop]); Mag.componentIndex = ShipMagazines.Count; ShipMagazines.Add(Mag); ShipComponents.Add(Mag); } } ShipMFC = new BindingList<MissileFireControlTN>(); for (int loop = 0; loop < ClassDefinition.ShipMFCDef.Count; loop++) { index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipMFCDef[loop]); ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop2 = 0; loop2 < ClassDefinition.ShipMFCCount[loop]; loop2++) { MissileFireControlTN MFC = new MissileFireControlTN(ClassDefinition.ShipMFCDef[loop]); MFC.componentIndex = ShipMFC.Count; int MFCIndex = loop2 + 1; MFC.Name = MFC.mFCSensorDef.Name + " #" + MFCIndex.ToString(); ShipMFC.Add(MFC); ShipComponents.Add(MFC); ShipFireControls.Add(MFC); } } ShipOrdnance = new Dictionary<OrdnanceDefTN, int>(); CurrentMagazineCapacity = 0; CurrentMagazineCapacityMax = ClassDefinition.TotalMagazineCapacity; CurrentLauncherMagCapacityMax = ClassDefinition.LauncherMagSpace; CurrentMagazineMagCapacityMax = ClassDefinition.MagazineMagSpace; ShipCIWS = new BindingList<CIWSTN>(); for (int loop = 0; loop < ClassDefinition.ShipCIWSDef.Count; loop++) { index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipCIWSDef[loop]); ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop2 = 0; loop2 < ClassDefinition.ShipCIWSCount[loop]; loop2++) { CIWSTN CIWS = new CIWSTN(ClassDefinition.ShipCIWSDef[loop]); CIWS.componentIndex = ShipCIWS.Count; int CIWSIndex = loop2 + 1; CIWS.Name = CIWS.cIWSDef.Name + " #" + CIWSIndex.ToString(); ShipCIWS.Add(CIWS); ShipComponents.Add(CIWS); } } ShipCIWSIndex = 0; ShipTurret = new BindingList<TurretTN>(); for (int loop = 0; loop < ClassDefinition.ShipTurretDef.Count; loop++) { index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipTurretDef[loop]); ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop2 = 0; loop2 < ClassDefinition.ShipTurretCount[loop]; loop2++) { TurretTN Turret = new TurretTN(ClassDefinition.ShipTurretDef[loop]); Turret.componentIndex = ShipTurret.Count; int TurretIndex = loop2 + 1; Turret.Name = Turret.turretDef.Name + " #" + TurretIndex.ToString(); ShipTurret.Add(Turret); ShipComponents.Add(Turret); } } ShipJumpEngine = new BindingList<JumpEngineTN>(); for (int loop = 0; loop < ClassDefinition.ShipJumpEngineDef.Count; loop++) { index = ClassDefinition.ListOfComponentDefs.IndexOf(ClassDefinition.ShipJumpEngineDef[loop]); ComponentDefIndex[index] = (ushort)ShipComponents.Count; for (int loop2 = 0; loop2 < ClassDefinition.ShipJumpEngineCount[loop]; loop2++) { JumpEngineTN JumpEngine = new JumpEngineTN(ClassDefinition.ShipJumpEngineDef[loop]); JumpEngine.componentIndex = ShipJumpEngine.Count; int JumpEngineIndex = loop2 + 1; JumpEngine.Name = JumpEngine.jumpEngineDef.Name + " #" + JumpEngineIndex.ToString(); ShipJumpEngine.Add(JumpEngine); ShipComponents.Add(JumpEngine); } } JumpSickness = 0; IsDestroyed = false; ShipsTargetting = new BindingList<ShipTN>(); TaskGroupsOrdered = new BindingList<TaskGroupTN>(); }
public void TGActiveTest() { EngineDefTN EngDef = new EngineDefTN("25 EP Nuclear Thermal Engine", 5, 1.0f, 1.0f, 1.0f, 1, 5, -1.0f); ActiveSensorDefTN ActDef1 = new ActiveSensorDefTN("Search 5M - 5000", 1.0f, 10, 5, 100, false, 1.0f, 1); ActiveSensorDefTN ActDef2 = new ActiveSensorDefTN("Search 500k - 1", 1.0f, 10, 5, 1, false, 1.0f, 1); ActiveSensorDefTN ActDef3 = new ActiveSensorDefTN("Search 2.2M - 1000", 1.0f, 10, 5, 20, false, 1.0f, 1); ActiveSensorDefTN ActDef4 = new ActiveSensorDefTN("Search 7M - 10000", 1.0f, 10, 5, 200, false, 1.0f, 1); GeneralComponentDefTN CrewQ = new GeneralComponentDefTN("Crew Quarters", 1.0f, 0, 10.0m, ComponentTypeTN.Crew); GeneralComponentDefTN FuelT = new GeneralComponentDefTN("Fuel Storage", 1.0f, 0, 10.0m, ComponentTypeTN.Fuel); GeneralComponentDefTN EBay = new GeneralComponentDefTN("Engineering Spaces", 1.0f, 5, 10.0m, ComponentTypeTN.Engineering); GeneralComponentDefTN Bridge = new GeneralComponentDefTN("Bridge", 1.0f, 5, 10.0m, ComponentTypeTN.Bridge); Faction FID = new Faction(0); StarSystem System = SystemGen.CreateSol(); SystemBody planet = new SystemBody(System.Stars[0], SystemBody.PlanetType.Terrestrial);; System.Stars[0].Planets.Add(planet); TaskGroupTN TaskGroup1 = new TaskGroupTN("Taskforce 001", FID, planet, System); for (int loop = 0; loop < 4; loop++) { ShipClassTN test = new ShipClassTN("Ship", FID); test.AddCrewQuarters(CrewQ, 2); test.AddFuelStorage(FuelT, 2); test.AddEngineeringSpaces(EBay, 2); Console.WriteLine("Bridge isn't present: {0} {1}", test.OtherComponents.IndexOf(Bridge), test.HasBridge); test.AddOtherComponent(Bridge, 1); Console.WriteLine("Bridge is present: {0} {1}", test.OtherComponents.IndexOf(Bridge), test.HasBridge); switch (loop) { case 0: test.AddActiveSensor(ActDef2, 2); break; case 1: test.AddActiveSensor(ActDef1, 2); break; case 2: test.AddActiveSensor(ActDef3, 2); break; case 3: test.AddActiveSensor(ActDef4, 2); break; } TaskGroup1.AddShip(test, "Test Ship"); TaskGroup1.SetActiveSensor(loop, 0, true); TaskGroup1.SetActiveSensor(loop, 1, true); } LinkedListNode<int> EM = TaskGroup1.EMSortList.First; for (int loop = 0; loop < 4; loop++) { Console.WriteLine("{0} {1}", TaskGroup1.Ships[loop].CurrentEMSignature, EM.Value); EM = EM.Next; } for (int loop = 0; loop < Constants.ShipTN.ResolutionMax; loop++) { Console.WriteLine("{0} | {1}", TaskGroup1.TaskGroupLookUpST[loop], loop); } TaskGroup1.SetActiveSensor(2, 0, false); TaskGroup1.SetActiveSensor(2, 1, false); Console.WriteLine("--------------------------------------------"); EM = TaskGroup1.EMSortList.First; for (int loop = 0; loop < 4; loop++) { Console.WriteLine("{0} {1}", TaskGroup1.Ships[loop].CurrentEMSignature, EM.Value); EM = EM.Next; } for (int loop = 0; loop < Constants.ShipTN.ResolutionMax; loop++) { Console.WriteLine("{0} | {1}", TaskGroup1.TaskGroupLookUpST[loop], loop); } }
public void TGActiveSortThermalSortTest() { EngineDefTN EngDef = new EngineDefTN("25 EP Nuclear Thermal Engine", 5, 1.0f, 1.0f, 1.0f, 1, 5, -1.0f); GeneralComponentDefTN CrewQ = new GeneralComponentDefTN("Crew Quarters", 1.0f, 0, 10.0m, ComponentTypeTN.Crew); GeneralComponentDefTN FuelT = new GeneralComponentDefTN("Fuel Storage", 1.0f, 0, 10.0m, ComponentTypeTN.Fuel); GeneralComponentDefTN EBay = new GeneralComponentDefTN("Engineering Spaces", 1.0f, 5, 10.0m, ComponentTypeTN.Engineering); GeneralComponentDefTN Bridge = new GeneralComponentDefTN("Bridge", 1.0f, 5, 10.0m, ComponentTypeTN.Bridge); Faction FID = new Faction(0); StarSystem System = SystemGen.CreateSol(); SystemBody planet = new SystemBody(System.Stars[0], SystemBody.PlanetType.Terrestrial);; System.Stars[0].Planets.Add(planet); TaskGroupTN TaskGroup1 = new TaskGroupTN("Taskforce 001", FID, planet, System); for (int loop = 0; loop < 5; loop++) { ShipClassTN test = new ShipClassTN("Ship", FID); test.AddCrewQuarters(CrewQ, 2); test.AddFuelStorage(FuelT, 2); test.AddEngineeringSpaces(EBay, 2); test.AddOtherComponent(Bridge, 1); int add = 0; switch (loop) { case 0: add = 2; break; case 1: add = 4; break; case 2: add = 1; break; case 3: add = 5; break; case 4: add = 3; break; } test.AddEngine(EngDef, (byte)add); Console.WriteLine("Speed:{0}", test.MaxSpeed); TaskGroup1.AddShip(test,"Test Ship"); Console.WriteLine("{0} {1}", TaskGroup1, TaskGroup1.Ships[loop].ShipsTaskGroup); } LinkedListNode<int> AS = TaskGroup1.ActiveSortList.First; LinkedListNode<int> ES = TaskGroup1.EMSortList.First; LinkedListNode<int> TS = TaskGroup1.ThermalSortList.First; for (int loop = 0; loop < 5; loop++) { Console.Write("AL:{0}, EL:{1}, TL:{2} || Ship{3} AL:{4}, EL:{5} TL:{6} |||", AS.Value, ES.Value, TS.Value, loop, TaskGroup1.Ships[loop].ActiveList.Value, TaskGroup1.Ships[loop].EMList.Value, TaskGroup1.Ships[loop].ThermalList.Value); Console.WriteLine("{0} {1} {2} {3} {4} {5} {6}", TaskGroup1.Ships[loop].CurrentSpeed, TaskGroup1.Ships[loop].CurrentEnginePower, TaskGroup1.Ships[loop].CurrentThermalSignature, TaskGroup1.Ships[loop].ShipClass.MaxEnginePower, TaskGroup1.Ships[loop].ShipClass.MaxThermalSignature, TaskGroup1.Ships[loop].CurrentFuelUsePerHour, TaskGroup1.Ships[loop].ShipClass.MaxFuelUsePerHour); AS = AS.Next; ES = ES.Next; TS = TS.Next; } TaskGroup1.Ships[4].CurrentThermalSignature = 500; TaskGroup1.SortShipBySignature(TaskGroup1.Ships[4].ThermalList, TaskGroup1.ThermalSortList, 0); Console.WriteLine("------------------------"); AS = TaskGroup1.ActiveSortList.First; ES = TaskGroup1.EMSortList.First; TS = TaskGroup1.ThermalSortList.First; for (int loop = 0; loop < 5; loop++) { Console.Write("AL:{0}, EL:{1}, TL:{2} || Ship{3} AL:{4}, EL:{5} TL:{6} |||", AS.Value, ES.Value, TS.Value, loop, TaskGroup1.Ships[loop].ActiveList.Value, TaskGroup1.Ships[loop].EMList.Value, TaskGroup1.Ships[loop].ThermalList.Value); Console.WriteLine("{0} {1} {2} {3} {4} {5} {6}", TaskGroup1.Ships[loop].CurrentSpeed, TaskGroup1.Ships[loop].CurrentEnginePower, TaskGroup1.Ships[loop].CurrentThermalSignature, TaskGroup1.Ships[loop].ShipClass.MaxEnginePower, TaskGroup1.Ships[loop].ShipClass.MaxThermalSignature, TaskGroup1.Ships[loop].CurrentFuelUsePerHour, TaskGroup1.Ships[loop].ShipClass.MaxFuelUsePerHour); AS = AS.Next; ES = ES.Next; TS = TS.Next; } }
/// <summary> /// TaskGroupEM Detection runs the EM detection routine on TaskGroupToTest from CurrentTaskGroup. This differs from Thermal in that we use the ship EM linked list as well as the faction EM /// Detection list. /// </summary> /// <param name="System">Current System this is taking place in.</param> /// <param name="CurrentTaskGroup">TaskGroup that is performing the sensor sweep.</param> /// <param name="TaskGroupToTest">TaskGroup being tested against.</param> /// <param name="dist">Distance between these two taskgroups.</param> /// <param name="detListIterator">Iterator for where the TaskGroupToTest is in the various detection lists and the system contact list.</param> /// <param name="DetShipList">If a ship is detected it must be put into this list for the detectedContactsList later on.</param> private void TaskGroupEMDetection(StarSystem System, TaskGroupTN CurrentTaskGroup, TaskGroupTN TaskGroupToTest, float dist, int detListIterator) { if (System.FactionDetectionLists[FactionID].EM[detListIterator] != GameState.Instance.CurrentSecond) { int sig = -1; int detection = -1; bool noDetection = false; bool allDetection = false; /// <summary> /// Get the best detection range for EM signatures in loop. /// </summary> int ShipID = TaskGroupToTest.EMSortList.Last(); ShipTN scratch = TaskGroupToTest.Ships[ShipID]; sig = scratch.CurrentEMSignature; /// <summary> /// Check to see if the taskgroup has an em sensor, and that said em sensor is not destroyed. /// otherwise use the default passive detection range. /// </summary> if (CurrentTaskGroup.BestEMCount > 0) { detection = CurrentTaskGroup.BestEM.pSensorDef.GetPassiveDetectionRange(sig); } else { detection = ComponentList.DefaultPassives.GetPassiveDetectionRange(sig); } bool det = LargeDetection(dist, detection); /// <summary> /// Good case, none of the ships are detected. /// </summary> if (det == false) { noDetection = true; } /// <summary> /// Atleast the biggest ship is detected. /// </summary if (noDetection == false) { ShipID = TaskGroupToTest.EMSortList.First(); scratch = TaskGroupToTest.Ships[ShipID]; sig = scratch.CurrentEMSignature; /// <summary> /// once again we must check here to make sure that the taskgroup does have a passive suite, or else use the default one. /// </summary> if (CurrentTaskGroup.BestEMCount > 0) { detection = CurrentTaskGroup.BestEM.pSensorDef.GetPassiveDetectionRange(sig); } else { detection = ComponentList.DefaultPassives.GetPassiveDetectionRange(sig); } det = LargeDetection(dist, detection); /// <summary> /// Best case, everything is detected. /// </summary> if (det == true) { allDetection = true; for (int loop3 = 0; loop3 < TaskGroupToTest.Ships.Count; loop3++) { TaskGroupToTest.Ships[loop3].EMDetection[FactionID] = GameState.Instance.CurrentSecond; if (DetShipList.Contains(TaskGroupToTest.Ships[loop3]) == false) { DetShipList.Add(TaskGroupToTest.Ships[loop3]); } } System.FactionDetectionLists[FactionID].EM[detListIterator] = GameState.Instance.CurrentSecond; } else if (noDetection == false && allDetection == false) { /// <summary> /// Worst case. some are detected, some aren't. /// </summary> for (int loop3 = 0; loop3 < TaskGroupToTest.Ships.Count; loop3++) { LinkedListNode<int> node = TaskGroupToTest.EMSortList.Last; bool done = false; while (!done) { scratch = TaskGroupToTest.Ships[node.Value]; if (scratch.EMDetection[FactionID] != GameState.Instance.CurrentSecond) { sig = scratch.CurrentEMSignature; /// <summary> /// here is where EM detection differs from Thermal detection: /// If a ship has a signature of 0 by this point(and we didn't already hit noDetection above, /// it means that one ship is emitting a signature, but that no other ships are. /// Mark the group as totally detected, but not the ships, this serves to tell me that the ships are undetectable /// in this case. /// </summary> if (sig == 0) { /// <summary> /// The last signature we looked at was the ship emitting an EM sig, and this one is not. /// Mark the entire group as "spotted" because no other detection will occur. /// </summary> if (TaskGroupToTest.Ships[node.Next.Value].EMDetection[FactionID] == GameState.Instance.CurrentSecond) { System.FactionDetectionLists[FactionID].EM[detListIterator] = GameState.Instance.CurrentSecond; } break; } if (CurrentTaskGroup.BestEMCount > 0) { detection = CurrentTaskGroup.BestEM.pSensorDef.GetPassiveDetectionRange(sig); } else { detection = ComponentList.DefaultPassives.GetPassiveDetectionRange(sig); } det = LargeDetection(dist, detection); if (det == true) { scratch.EMDetection[FactionID] = GameState.Instance.CurrentSecond; if (DetShipList.Contains(scratch) == false) { DetShipList.Add(scratch); } } else { done = true; break; } } if (node == TaskGroupToTest.EMSortList.First) { /// <summary> /// This should not happen. /// </summary> String ErrorMessage = string.Format("Partial EM detect for TGs looped through every ship. {0} {1} {2} {3}", dist, detection, noDetection, allDetection); MessageEntry NMsg = new MessageEntry(MessageEntry.MessageType.Error, CurrentTaskGroup.Contact.Position.System, CurrentTaskGroup.Contact, GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, ErrorMessage); MessageLog.Add(NMsg); done = true; break; } node = node.Previous; } } } /// <summary> /// End else /// </summary> } } }
/// <summary> /// TaskGroupThermal Detection runs the thermal detection routine on TaskGroupToTest from CurrentTaskGroup /// </summary> /// <param name="System">Current System this is taking place in.</param> /// <param name="CurrentTaskGroup">TaskGroup that is performing the sensor sweep.</param> /// <param name="TaskGroupToTest">TaskGroup being tested against.</param> /// <param name="dist">Distance between these two taskgroups.</param> /// <param name="detListIterator">Iterator for where the TaskGroupToTest is in the various detection lists and the system contact list.</param> /// <param name="DetShipList">If a ship is detected it must be put into this list for the detectedContactsList later on.</param> private void TaskGroupThermalDetection(StarSystem System, TaskGroupTN CurrentTaskGroup, TaskGroupTN TaskGroupToTest, float dist, int detListIterator) { if (System.FactionDetectionLists[FactionID].Thermal[detListIterator] != GameState.Instance.CurrentSecond) { int sig = -1; int detection = -1; bool noDetection = false; bool allDetection = false; /// <summary> /// Get the best detection range for thermal signatures in loop. /// </summary> int ShipID = TaskGroupToTest.ThermalSortList.Last(); ShipTN scratch = TaskGroupToTest.Ships[ShipID]; sig = scratch.CurrentThermalSignature; /// <summary> /// Check to make sure the taskgroup has a thermal sensor available, otherwise use the default. /// </summary> if (CurrentTaskGroup.BestThermalCount != 0) { detection = CurrentTaskGroup.BestThermal.pSensorDef.GetPassiveDetectionRange(sig); } else { detection = ComponentList.DefaultPassives.GetPassiveDetectionRange(sig); } /// <summary> /// Test the biggest signature against the best sensor. /// </summary> bool det = LargeDetection(dist, detection); /// <summary> /// Good case, none of the ships are detected. /// </summary> if (det == false) { noDetection = true; } /// <summary> /// Atleast the biggest ship is detected. /// </summary if (noDetection == false) { ShipID = TaskGroupToTest.ThermalSortList.First(); scratch = TaskGroupToTest.Ships[ShipID]; sig = scratch.CurrentThermalSignature; /// <summary> /// Check to make sure the taskgroup has a thermal sensor available, otherwise use the default. /// </summary> if (CurrentTaskGroup.BestThermalCount != 0) { detection = CurrentTaskGroup.BestThermal.pSensorDef.GetPassiveDetectionRange(sig); } else { detection = ComponentList.DefaultPassives.GetPassiveDetectionRange(sig); } /// <summary> /// Now for the smallest vs the best. /// </summary> det = LargeDetection(dist, detection); /// <summary> /// Best case, everything is detected. /// </summary> if (det == true) { allDetection = true; for (int loop3 = 0; loop3 < TaskGroupToTest.Ships.Count; loop3++) { TaskGroupToTest.Ships[loop3].ThermalDetection[FactionID] = GameState.Instance.CurrentSecond; if (DetShipList.Contains(TaskGroupToTest.Ships[loop3]) == false) { DetShipList.Add(TaskGroupToTest.Ships[loop3]); } } System.FactionDetectionLists[FactionID].Thermal[detListIterator] = GameState.Instance.CurrentSecond; } else if (noDetection == false && allDetection == false) { /// <summary> /// Worst case. some are detected, some aren't. /// </summary> for (int loop3 = 0; loop3 < TaskGroupToTest.Ships.Count; loop3++) { LinkedListNode<int> node = TaskGroupToTest.ThermalSortList.Last; bool done = false; while (!done) { scratch = TaskGroupToTest.Ships[node.Value]; if (scratch.ThermalDetection[FactionID] != GameState.Instance.CurrentSecond) { sig = scratch.CurrentThermalSignature; if (CurrentTaskGroup.BestThermalCount != 0) { detection = CurrentTaskGroup.BestThermal.pSensorDef.GetPassiveDetectionRange(sig); } else { detection = ComponentList.DefaultPassives.GetPassiveDetectionRange(sig); } /// <summary> /// Test each ship until I get to one I don't see. /// </summary> det = LargeDetection(dist, detection); if (det == true) { scratch.ThermalDetection[FactionID] = GameState.Instance.CurrentSecond; if (DetShipList.Contains(scratch) == false) { DetShipList.Add(scratch); } } else { done = true; break; } } if (node == TaskGroupToTest.ThermalSortList.First) { /// <summary> /// This should not happen. /// </summary> String ErrorMessage = string.Format("Partial Thermal detect for TGs looped through every ship. {0} {1} {2} {3}", dist, detection, noDetection, allDetection); MessageEntry NMsg = new MessageEntry(MessageEntry.MessageType.Error, TaskGroupToTest.Contact.Position.System, TaskGroupToTest.Contact, GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, ErrorMessage); MessageLog.Add(NMsg); done = true; break; } node = node.Previous; } } } /// <summary> /// End else /// </summary> } } }
/// <summary> /// Adds a TG to the fleet intercept preempt list. /// </summary> /// <param name="TG">taskgroup to be added</param> public void AddFleetToPreemptList(TaskGroupTN TG) { FleetInterceptPreemptList.Add(TG); }
/// <summary> /// Determines if a TaskGroup has the ability to jump through this JumpPoint. /// Ensures a connection, and checks Gate, Gate Ownership, and JumpDrives. /// </summary> /// <param name="TransitTG">TG requesting Transit.</param> /// <param name="IsStandardTransit">True if StandardTransit, False if SquadronTransit</param> /// <returns>True if TG is capable of doing this jump.</returns> public bool CanJump(TaskGroupTN TransitTG, bool IsStandardTransit, out Dictionary<JumpEngineTN,ShipTN> usedJumpEngines) { usedJumpEngines = null; // Ensure we have a connection, if not create one. if (Connect == null) { CreateConnection(); } if (IsGated && IsStandardTransit == true) { if (Constants.GameSettings.AllowHostileGateJump || AllowHostileJumps) { // Gate/Game settings are not setup to allow blocking of hostiles. return true; } if (GateOwner == null || GateOwner == TransitTG.TaskGroupFaction) { // Nobody owns the gate, or we do, allow the jump. ///< @todo Check if a friendly faction owns the gate, and allow. return true; } } /// <summary> /// jump Transit code: /// </summary> int ComCount = 0; int MilCount = 0; float ComMaxHS = 0; float MilMaxHS = 0; int MilAccom = 0; int ComAccom = 0; /// <summary> /// For every ship: /// How many of each type of ship are there? /// What are the largest ship sizes in HS? /// Go through every jump engine /// Is this jump engine ready? /// Can this jump engine accomodate the other ships in the taskgroup? /// </summary> TransitTG.CountShips(out MilCount, out ComCount, out MilMaxHS, out ComMaxHS); /// <summary> /// if one ship can be accomodated all can be. /// </summary> if (IsStandardTransit == true) { if(MilCount > 1) MilCount = 1; if(ComCount > 1) ComCount = 1; } TransitTG.GetJDAccom(MilMaxHS, MilCount, ComMaxHS, ComCount, out MilAccom, out ComAccom, out usedJumpEngines); /// <summary> /// This jump can happen. /// </summary> if (MilAccom >= MilCount && ComAccom >= ComCount) { return true; } /// <summary> /// Something caused this jump to fail, will need to find out what for the faction messagelog though. /// </summary> return false; }
/// <summary> /// Constructor for TaskGroup related orders /// </summary> /// <param name="TypeOrder">Type</param> /// <param name="SecondaryOrder">Any secondary order specification such as installation type.</param> /// <param name="TertiaryOrder"> Any Tertiary order such as limits.</param> /// <param name="Delay">Delay in seconds before performing this order.</param> /// <param name="TaskGroupOrder">The TaskGroup in question.</param> public Order(Constants.ShipTN.OrderType TypeOrder, int SecondaryOrder, int TertiaryOrder, int Delay, TaskGroupTN TaskGroupOrder) { TypeOf = TypeOrder; Target = TaskGroupOrder.Contact; Secondary = SecondaryOrder; Tertiary = TertiaryOrder; TaskGroup = TaskGroupOrder; OrderDelay = Delay; OrderTimeRequirement = -1; Name = TypeOrder.ToString() + " " + TaskGroupOrder.Name.ToString(); }
public void testASensor() { Faction newFaction = new Faction(0); StarSystem System1 = SystemGen.CreateSol(); SystemBody pl1 = new SystemBody(System1.Stars[0], SystemBody.PlanetType.Terrestrial); System1.Stars[0].Planets.Add(pl1); TaskGroupTN newTG = new TaskGroupTN("TG", newFaction, System1.Stars[0].Planets[0], System1); ShipClassTN ts2 = new ShipClassTN("Test", newFaction); ShipTN ts = new ShipTN(ts2, 0, 0, newTG, newFaction, "Test Ship"); ActiveSensorDefTN ASensorDefTest = new ActiveSensorDefTN("Active Search Sensor MR705-R185", 6.0f, 36, 24, 185, false, 1.0f, 1); ts2.ShipASensorDef = new BindingList<ActiveSensorDefTN>(); ts2.ShipASensorCount = new BindingList<ushort>(); ts2.ShipASensorDef.Add(ASensorDefTest); ts2.ShipASensorCount.Add(1); ActiveSensorTN ASensorTest = new ActiveSensorTN(ts2.ShipASensorDef[0]); ts.ShipASensor = new BindingList<ActiveSensorTN>(); ts.ShipASensor.Add(ASensorTest); ActiveSensorDefTN tst3 = ts.ShipASensor[0].aSensorDef; Console.WriteLine("Name: {0}", tst3.Name); Console.WriteLine("Size: {0}, HTK: {1}, Hardening: {2}", tst3.size, tst3.htk, tst3.hardening); Console.WriteLine("GPS: {0}, Range: {1}", tst3.gps, tst3.maxRange); Console.WriteLine("IsMilitary: {0}", tst3.isMilitary); Console.WriteLine("Crew: {0}", tst3.crew); Console.WriteLine("Cost: {0}", tst3.cost); for (ushort loop = 80; loop < 120; loop++) { Console.WriteLine("Resolution:{0} Detection Range in KM:{1}", loop, tst3.GetActiveDetectionRange(loop, -1)); } }
/// <summary> /// Taskgroup active detection will handle the active detection sensor sweeps, Resolution represents the biggest difference for TG Active detection vs passive detection. /// There isn't simply a best active sensor, and the correct one has to be searched for. luckily that work is already done by the taskgroup itself. /// </summary> /// <param name="System">Current System.</param> /// <param name="CurrentTaskGroup">Scanning Taskgroup</param> /// <param name="TaskGroupToTest">Taskgroup to test if detected.</param> /// <param name="dist">Distance between the two taskgroups</param> /// <param name="detListIterator">location of the test taskgroup in the detection lists</param> private void TaskGroupActiveDetection(StarSystem System, TaskGroupTN CurrentTaskGroup, TaskGroupTN TaskGroupToTest, float dist, int detListIterator) { if (System.FactionDetectionLists[FactionID].Active[detListIterator] != GameState.Instance.CurrentSecond && CurrentTaskGroup.ActiveSensorQue.Count > 0) { int sig = -1; int detection = -1; bool noDetection = false; bool allDetection = false; /// <summary> /// Get the best detection range for thermal signatures in loop. /// </summary> int ShipID = TaskGroupToTest.ActiveSortList.Last(); ShipTN scratch = TaskGroupToTest.Ships[ShipID]; sig = scratch.TotalCrossSection - 1; if (sig > Constants.ShipTN.ResolutionMax - 1) sig = Constants.ShipTN.ResolutionMax - 1; detection = CurrentTaskGroup.ActiveSensorQue[CurrentTaskGroup.TaskGroupLookUpST[sig]].aSensorDef.GetActiveDetectionRange(sig, -1); bool det = LargeDetection(dist, detection); /// <summary> /// Good case, none of the ships are detected. /// </summary> if (det == false) { noDetection = true; } /// <summary> /// Atleast the biggest ship is detected. /// </summary if (noDetection == false) { ShipID = TaskGroupToTest.ActiveSortList.First(); scratch = TaskGroupToTest.Ships[ShipID]; sig = scratch.TotalCrossSection - 1; if (sig > Constants.ShipTN.ResolutionMax - 1) sig = Constants.ShipTN.ResolutionMax - 1; detection = CurrentTaskGroup.ActiveSensorQue[CurrentTaskGroup.TaskGroupLookUpST[sig]].aSensorDef.GetActiveDetectionRange(sig, -1); det = LargeDetection(dist, detection); /// <summary> /// Best case, everything is detected. /// </summary> if (det == true) { allDetection = true; for (int loop3 = 0; loop3 < TaskGroupToTest.Ships.Count; loop3++) { TaskGroupToTest.Ships[loop3].ActiveDetection[FactionID] = GameState.Instance.CurrentSecond; if (DetShipList.Contains(TaskGroupToTest.Ships[loop3]) == false) { DetShipList.Add(TaskGroupToTest.Ships[loop3]); } } /// <summary> /// FactionSystemDetection entry. I hope to deprecate this at some point. /// Be sure to erase the factionDetectionSystem entry first, to track down everywhere this overbloated thing is. /// update, not happening. FactionDetectionList is too important. /// </summary> System.FactionDetectionLists[FactionID].Active[detListIterator] = GameState.Instance.CurrentSecond; } else if (noDetection == false && allDetection == false) { /// <summary> /// Worst case. some are detected, some aren't. /// </summary> for (int loop3 = 0; loop3 < TaskGroupToTest.Ships.Count; loop3++) { LinkedListNode<int> node = TaskGroupToTest.ActiveSortList.Last; bool done = false; while (!done) { scratch = TaskGroupToTest.Ships[node.Value]; if (scratch.ActiveDetection[FactionID] != GameState.Instance.CurrentSecond) { sig = scratch.TotalCrossSection - 1; if (sig > Constants.ShipTN.ResolutionMax - 1) sig = Constants.ShipTN.ResolutionMax - 1; detection = CurrentTaskGroup.ActiveSensorQue[CurrentTaskGroup.TaskGroupLookUpST[sig]].aSensorDef.GetActiveDetectionRange(sig, -1); det = LargeDetection(dist, detection); if (det == true) { scratch.ActiveDetection[FactionID] = GameState.Instance.CurrentSecond; if (DetShipList.Contains(scratch) == false) { DetShipList.Add(scratch); } } else { done = true; break; } } if (node == TaskGroupToTest.ActiveSortList.First) { /// <summary> /// This should not happen. /// </summary> String ErrorMessage = string.Format("Partial Active detect for TGs looped through every ship. {0} {1} {2} {3}", dist, detection, noDetection, allDetection); MessageEntry NMsg = new MessageEntry(MessageEntry.MessageType.Error, CurrentTaskGroup.Contact.Position.System, CurrentTaskGroup.Contact, GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, ErrorMessage); MessageLog.Add(NMsg); done = true; break; } node = node.Previous; } } } /// <summary> /// End else /// </summary> } } }
public void testShip() { Faction newFaction = new Faction(0); /// <summary> /// These would go into a faction component list I think /// </summary> EngineDefTN EngDef = new EngineDefTN("25 EP Nuclear Thermal Engine", 5, 1.0f, 1.0f, 1.0f, 1, 5, -1.0f); ActiveSensorDefTN ActDef = new ActiveSensorDefTN("Search 5M - 5000", 1.0f, 10, 5, 100, false, 1.0f, 1); PassiveSensorDefTN ThPasDef = new PassiveSensorDefTN("Thermal Sensor TH1-5", 1.0f, 5, PassiveSensorType.Thermal, 1.0f, 1); PassiveSensorDefTN EMPasDef = new PassiveSensorDefTN("EM Sensor EM1-5", 1.0f, 5, PassiveSensorType.EM, 1.0f, 1); GeneralComponentDefTN CrewQ = new GeneralComponentDefTN("Crew Quarters", 1.0f, 0, 10.0m, ComponentTypeTN.Crew); GeneralComponentDefTN FuelT = new GeneralComponentDefTN("Fuel Storage", 1.0f, 0, 10.0m, ComponentTypeTN.Fuel); GeneralComponentDefTN EBay = new GeneralComponentDefTN("Engineering Spaces", 1.0f, 5, 10.0m, ComponentTypeTN.Engineering); GeneralComponentDefTN Bridge = new GeneralComponentDefTN("Bridge", 1.0f, 5, 10.0m, ComponentTypeTN.Bridge); ShipClassTN TestClass = new ShipClassTN("Test Ship Class", newFaction); TestClass.AddCrewQuarters(CrewQ, 2); TestClass.AddFuelStorage(FuelT, 2); TestClass.AddEngineeringSpaces(EBay, 2); TestClass.AddOtherComponent(Bridge, 1); TestClass.AddEngine(EngDef, 1); TestClass.AddPassiveSensor(ThPasDef, 1); TestClass.AddPassiveSensor(EMPasDef, 1); TestClass.AddActiveSensor(ActDef, 1); Console.WriteLine("Size: {0}, Crew: {1}, Cost: {2}, HTK: {3}, Tonnage: {4}", TestClass.SizeHS, TestClass.TotalRequiredCrew, TestClass.BuildPointCost, TestClass.TotalHTK, TestClass.SizeTons); Console.WriteLine("HS Accomodations/Required: {0}/{1}, Total Fuel Capacity: {2}, Total MSP: {3}, Engineering percentage: {4}, Has Bridge: {5}, Total Required Crew: {6}", TestClass.AccomHSAvailable, TestClass.AccomHSRequirement, TestClass.TotalFuelCapacity, TestClass.TotalMSPCapacity, (TestClass.EngineeringHS / TestClass.SizeHS), TestClass.HasBridge, TestClass.TotalRequiredCrew); Console.WriteLine("Armor Size: {0}, Cost: {1}", TestClass.ShipArmorDef.size, TestClass.ShipArmorDef.cost); Console.WriteLine("Ship Engine Power: {0}, Ship Thermal Signature: {1}, Ship Fuel Use Per Hour: {2}", TestClass.MaxEnginePower, TestClass.MaxThermalSignature, TestClass.MaxFuelUsePerHour); Console.WriteLine("Best TH: {0}, BestEM: {1}, Max EM Signature: {2}, Total Cross Section: {3}", TestClass.BestThermalRating, TestClass.BestEMRating, TestClass.MaxEMSignature, TestClass.TotalCrossSection); TestClass.AddCrewQuarters(CrewQ, -1); Console.WriteLine("Size: {0}, Crew: {1}, Cost: {2}, HTK: {3}, Tonnage: {4}", TestClass.SizeHS, TestClass.TotalRequiredCrew, TestClass.BuildPointCost, TestClass.TotalHTK, TestClass.SizeTons); Console.WriteLine("HS Accomodations/Required: {0}/{1}, Total Fuel Capacity: {2}, Total MSP: {3}, Engineering percentage: {4}, Has Bridge: {5}, Total Required Crew: {6}", TestClass.AccomHSAvailable, TestClass.AccomHSRequirement, TestClass.TotalFuelCapacity, TestClass.TotalMSPCapacity, (TestClass.EngineeringHS / TestClass.SizeHS), TestClass.HasBridge, TestClass.TotalRequiredCrew); Console.WriteLine("Armor Size: {0}, Cost: {1}", TestClass.ShipArmorDef.size, TestClass.ShipArmorDef.cost); Console.WriteLine("Ship Engine Power: {0}, Ship Thermal Signature: {1}, Ship Fuel Use Per Hour: {2}", TestClass.MaxEnginePower, TestClass.MaxThermalSignature, TestClass.MaxFuelUsePerHour); Console.WriteLine("Best TH: {0}, BestEM: {1}, Max EM Signature: {2}, Total Cross Section: {3}", TestClass.BestThermalRating, TestClass.BestEMRating, TestClass.MaxEMSignature, TestClass.TotalCrossSection); TestClass.AddCrewQuarters(CrewQ, -1); Console.WriteLine("Size: {0}, Crew: {1}, Cost: {2}, HTK: {3}, Tonnage: {4}", TestClass.SizeHS, TestClass.TotalRequiredCrew, TestClass.BuildPointCost, TestClass.TotalHTK, TestClass.SizeTons); Console.WriteLine("HS Accomodations/Required: {0}/{1}, Total Fuel Capacity: {2}, Total MSP: {3}, Engineering percentage: {4}, Has Bridge: {5}, Total Required Crew: {6}", TestClass.AccomHSAvailable, TestClass.AccomHSRequirement, TestClass.TotalFuelCapacity, TestClass.TotalMSPCapacity, (TestClass.EngineeringHS / TestClass.SizeHS), TestClass.HasBridge, TestClass.TotalRequiredCrew); Console.WriteLine("Armor Size: {0}, Cost: {1}", TestClass.ShipArmorDef.size, TestClass.ShipArmorDef.cost); Console.WriteLine("Ship Engine Power: {0}, Ship Thermal Signature: {1}, Ship Fuel Use Per Hour: {2}", TestClass.MaxEnginePower, TestClass.MaxThermalSignature, TestClass.MaxFuelUsePerHour); Console.WriteLine("Best TH: {0}, BestEM: {1}, Max EM Signature: {2}, Total Cross Section: {3}", TestClass.BestThermalRating, TestClass.BestEMRating, TestClass.MaxEMSignature, TestClass.TotalCrossSection); TestClass.AddCrewQuarters(CrewQ, 2); StarSystem System1 = SystemGen.CreateSol(); SystemBody pl1 = new SystemBody(System1.Stars[0], SystemBody.PlanetType.Terrestrial); System1.Stars[0].Planets.Add(pl1); TaskGroupTN newTG = new TaskGroupTN("TG", newFaction, System1.Stars[0].Planets[0], System1); ShipTN testShip = new ShipTN(TestClass, 0, 0, newTG, newFaction, "Test Ship"); testShip.CrewQuarters[0].isDestroyed = true; for (int loop = 0; loop < testShip.CrewQuarters.Count; loop++) { Console.WriteLine("Crew Quarters {0} isDestroyed:{1}", loop + 1, testShip.CrewQuarters[loop].isDestroyed); } testShip.CrewQuarters[0].isDestroyed = false; Console.WriteLine("Engine Power/Fuel Usage/Thermal Signature/Speed: {0}/{1}/{2}/{3}", testShip.CurrentEnginePower, testShip.CurrentFuelUsePerHour, testShip.CurrentThermalSignature, testShip.CurrentSpeed); testShip.SetSpeed(1000); Console.WriteLine("Engine Power/Fuel Usage/Thermal Signature/Speed: {0}/{1}/{2}/{3}", testShip.CurrentEnginePower, testShip.CurrentFuelUsePerHour, testShip.CurrentThermalSignature, testShip.CurrentSpeed); Console.WriteLine("Current Crew/Fuel/MSP: {0}/{1}/{2}", testShip.CurrentCrew, testShip.CurrentFuel, testShip.CurrentMSP); int CrewSource = 100000; float FuelSource = 100000.0f; int MSPSource = 100000; CrewSource = testShip.Recrew(CrewSource); FuelSource = testShip.Refuel(FuelSource); MSPSource = testShip.Resupply(MSPSource); Console.WriteLine("Current Crew/Fuel/MSP: {0}/{1}/{2} Source: {3}/{4}/{5}", testShip.CurrentCrew, testShip.CurrentFuel, testShip.CurrentMSP, CrewSource, FuelSource, MSPSource); Console.WriteLine("Current EM Signature: {0}", testShip.CurrentEMSignature); bool isActive = true; testShip.SetSensor(testShip.ShipASensor[0], isActive); Console.WriteLine("Current EM Signature: {0}", testShip.CurrentEMSignature); isActive = false; testShip.SetSpeed(1500); testShip.SetSensor(testShip.ShipASensor[0], isActive); Console.WriteLine("Engine Power/Fuel Usage/Thermal Signature/Speed: {0}/{1}/{2}/{3}", testShip.CurrentEnginePower, testShip.CurrentFuelUsePerHour, testShip.CurrentThermalSignature, testShip.CurrentSpeed); Console.WriteLine("Current EM Signature: {0}", testShip.CurrentEMSignature); }
/// <summary> /// Adds a new taskgroup to the taskgroups list at location StartBody in System StartSystem. /// </summary> /// <param name="Title">Name.</param> /// <param name="StartBody">Body with population that built the ship that will be put into the TG.</param> /// <param name="StartSystem">System in which the TG starts in.</param> public void AddNewTaskGroup(String Title, OrbitingEntity StartBody, StarSystem StartSystem) { TaskGroupTN TG = new TaskGroupTN(Title, this, StartBody, StartSystem); TaskGroups.Add(TG); }
public void TGPassivesTest() { EngineDefTN EngDef = new EngineDefTN("25 EP Nuclear Thermal Engine", 5, 1.0f, 1.0f, 1.0f, 1, 5, -1.0f); PassiveSensorDefTN ThPasDef1 = new PassiveSensorDefTN("Thermal Sensor TH1-5", 1.0f, 5, PassiveSensorType.Thermal, 1.0f, 1); PassiveSensorDefTN ThPasDef2 = new PassiveSensorDefTN("Thermal Sensor TH1-6", 1.0f, 6, PassiveSensorType.Thermal, 1.0f, 1); PassiveSensorDefTN ThPasDef3 = new PassiveSensorDefTN("Thermal Sensor TH1-8", 1.0f, 8, PassiveSensorType.Thermal, 1.0f, 1); PassiveSensorDefTN ThPasDef4 = new PassiveSensorDefTN("Thermal Sensor TH1-11", 1.0f, 11, PassiveSensorType.Thermal, 1.0f, 1); GeneralComponentDefTN CrewQ = new GeneralComponentDefTN("Crew Quarters", 1.0f, 0, 10.0m, ComponentTypeTN.Crew); GeneralComponentDefTN FuelT = new GeneralComponentDefTN("Fuel Storage", 1.0f, 0, 10.0m, ComponentTypeTN.Fuel); GeneralComponentDefTN EBay = new GeneralComponentDefTN("Engineering Spaces", 1.0f, 5, 10.0m, ComponentTypeTN.Engineering); GeneralComponentDefTN Bridge = new GeneralComponentDefTN("Bridge", 1.0f, 5, 10.0m, ComponentTypeTN.Bridge); Faction FID = new Faction(0); StarSystem System = SystemGen.CreateSol(); SystemBody planet = new SystemBody(System.Stars[0], SystemBody.PlanetType.Terrestrial);; System.Stars[0].Planets.Add(planet); TaskGroupTN TaskGroup1 = new TaskGroupTN("Taskforce 001", FID, planet, System); for (int loop = 0; loop < 4; loop++) { ShipClassTN test = new ShipClassTN("Ship", FID); test.AddCrewQuarters(CrewQ, 2); test.AddFuelStorage(FuelT, 2); test.AddEngineeringSpaces(EBay, 2); test.AddOtherComponent(Bridge, 1); switch (loop) { case 0: test.AddPassiveSensor(ThPasDef2, 5); break; case 1: test.AddPassiveSensor(ThPasDef1, 4); break; case 2: test.AddPassiveSensor(ThPasDef3, 7); break; case 3: test.AddPassiveSensor(ThPasDef4, 6); break; } TaskGroup1.AddShip(test, "Test Ship"); Console.WriteLine("Best Thermal:{0},{1}", TaskGroup1.BestThermal.pSensorDef.rating, TaskGroup1.BestThermalCount); } }
/// <summary> /// creates a list of orders by creating a union and intersection of other lists. /// </summary> /// <param name="thisTG"></param> /// <param name="targetEntity"></param> /// <param name="previousOrders"></param> /// <returns></returns> private List<Constants.ShipTN.OrderType> legalOrders(TaskGroupTN thisTG, StarSystemEntity targetEntity, List<Order> previousOrders) { List<Constants.ShipTN.OrderType> thisTGLegalOrders = new List<Constants.ShipTN.OrderType>(); List<Constants.ShipTN.OrderType> additionalOrders = new List<Constants.ShipTN.OrderType>(); List<Constants.ShipTN.OrderType> targetEntityLegalOrders = targetEntity.LegalOrders(CurrentTaskGroup.TaskGroupFaction); if (!m_oTaskGroupPanel.OrderFilteringCheckBox.Checked) { thisTGLegalOrders = Enum.GetValues(typeof(Constants.ShipTN.OrderType)).Cast<Constants.ShipTN.OrderType>().ToList(); } else { thisTGLegalOrders = thisTG.LegalOrdersTG(); foreach (var order in previousOrders) { additionalOrders = additionalOrders.Union(order.EnablesTypeOf()).ToList(); } thisTGLegalOrders = thisTGLegalOrders.Union(additionalOrders).ToList(); } //it still needs to do an intersect with the targetEntityLegalOrders, regardless of filtering. thisTGLegalOrders = thisTGLegalOrders.Intersect(targetEntityLegalOrders).ToList(); return thisTGLegalOrders; }
public void TGOrdersTest() { EngineDefTN EngDef = new EngineDefTN("25 EP Nuclear Thermal Engine", 5, 1.0f, 1.0f, 1.0f, 1, 5, -1.0f); GeneralComponentDefTN CrewQ = new GeneralComponentDefTN("Crew Quarters", 1.0f, 0, 10.0m, ComponentTypeTN.Crew); GeneralComponentDefTN FuelT = new GeneralComponentDefTN("Fuel Storage", 1.0f, 0, 10.0m, ComponentTypeTN.Fuel); GeneralComponentDefTN EBay = new GeneralComponentDefTN("Engineering Spaces", 1.0f, 5, 10.0m, ComponentTypeTN.Engineering); GeneralComponentDefTN Bridge = new GeneralComponentDefTN("Bridge", 1.0f, 5, 10.0m, ComponentTypeTN.Bridge); Faction FID = new Faction(0); StarSystem System = SystemGen.CreateSol(); SystemBody planet = new SystemBody(System.Stars[0], SystemBody.PlanetType.Terrestrial);; System.Stars[0].Planets.Add(planet); Waypoint WP1 = new Waypoint("WP TG Orders", System, 0.1, 0.1, 0); planet.Position.X = 0.0; planet.Position.Y = 0.0; TaskGroupTN TaskGroup1 = new TaskGroupTN("Taskforce 001", FID, planet, System); ShipClassTN test = new ShipClassTN("Ship", FID); test.AddCrewQuarters(CrewQ, 2); test.AddFuelStorage(FuelT, 2); test.AddEngineeringSpaces(EBay, 2); test.AddOtherComponent(Bridge, 1); test.AddEngine(EngDef, 1); TaskGroup1.AddShip(test, "Test Ship"); TaskGroup1.Ships[0].Refuel(200000.0f); Order TGOrder = new Order(Constants.ShipTN.OrderType.MoveTo, -1, -1, 0, WP1); TaskGroup1.IssueOrder(TGOrder); Console.WriteLine("Fuel Remaining:{0}", TaskGroup1.Ships[0].CurrentFuel); while (TaskGroup1.TaskGroupOrders.Count != 0) { TaskGroup1.FollowOrders(5); Console.WriteLine("{0} {1} | {2} {3}", Distance.ToKm(TaskGroup1.Contact.Position.X), Distance.ToKm(TaskGroup1.Contact.Position.Y), TaskGroup1.Contact.Position.X, TaskGroup1.Contact.Position.Y); } Console.WriteLine("Fuel Remaining:{0}", TaskGroup1.Ships[0].CurrentFuel); }
/// <summary> /// Given a ship in this taskgroup, transfer said ship to TaskGroupTo /// </summary> /// <param name="Ship">Ship present in this taskgroup that should be transfered</param> /// <param name="TaskGroupTo">Taskgroup that will receive this ship</param> public void TransferShipToTaskGroup(ShipTN Ship, TaskGroupTN TaskGroupTo) { /// <summary> /// This ship is not in the taskgroup so return immediately. /// </summary> if (Ships.Contains(Ship) == false) return; BindingList<int> activeSensorIndices = new BindingList<int>(); for (int activeIterator = 0; activeIterator < Ship.ShipASensor.Count; activeIterator++) { /// <summary> /// This active sensor is both active and intact, so preserve its index, and set isActive to false(the sensor will be reactivated in its new TG. /// Destroyed sensors can keep their isActive state, as when they are repaired the repair function should handle reactivating them. /// </summary> if (Ship.ShipASensor[activeIterator].isActive == true && Ship.ShipASensor[activeIterator].isDestroyed == false) { activeSensorIndices.Add(activeIterator); Ship.ShipASensor[activeIterator].isActive = false; } } /// <summary> /// Move the ship between the two. /// </summary> RemoveShipFrom(Ship); TaskGroupTo.AddShipTo(Ship); /// <summary> /// reactivate any sensors that were active in the previous taskgroup. /// </summary> int ShipIndex = TaskGroupTo.Ships.IndexOf(Ship); foreach(int activeIndex in activeSensorIndices) TaskGroupTo.SetActiveSensor(ShipIndex, activeIndex, true); }