private Crewable(Part part, PartCrewManifest manifest, int capacity)
{
this.part = part;
this.manifest = manifest;
Capacity = capacity;
crewSlots = CrewSlot.GetSlots(part, manifest);
}
/// <summary>
/// Clears all crew out of the crewable.
/// </summary>
public void Clear()
{
for (int index = 0; index < Capacity; ++index)
{
manifest.RemoveCrewFromSeat(index);
}
crewSlots = CrewSlot.GetSlots(part, manifest);
}
/// <summary>
/// If the ship has no probe cores with SAS, try to make sure that there's at least one pilot.
/// Returns the available SAS level (-1 if no SAS present).
/// </summary>
/// <param name="construct"></param>
/// <param name="crewables"></param>
private static int TryEnsureSAS(ShipConstruct construct, CrewableList crewables)
{
// Do we have SAS?
int sasLevel = GetHighestSASLevel(construct);
// get the highest-level pilot
ProtoCrewMember highestPilot = GetHighestAssignedLevel(crewables.Command, PILOT_PROFESSION);
int pilotLevel = (highestPilot == null) ? -1 : highestPilot.experienceLevel;
int maxSas = (sasLevel > pilotLevel) ? sasLevel : pilotLevel;
if (maxSas >= 0)
{
// we already have SAS on the ship, don't need to add a pilot
if ((sasLevel < 0) && (pilotLevel > sasLevel))
{
Logging.Log(Logging.ToString(highestPilot) + " is already assigned and will provide SAS");
}
return(maxSas);
}
// There's no SAS control, we need to add a pilot somewhere.
// Try to find a slot to put a pilot
CrewSlot pilotSlot = Crewable.FindEmptySlot(crewables.Command);
if (pilotSlot == null)
{
Logging.Warn("SAS will be unavailable (no probe cores, no open slots to add a pilot)");
return(maxSas);
}
// Try to find a pilot to assign.
ProtoCrewMember lowestPilot;
if (!FindHighestLowestAvailable(PILOT_PROFESSION, 0, crewables, out highestPilot, out lowestPilot))
{
Logging.Warn("SAS will be unavailable (no probe cores, no available pilots)");
return(maxSas);
}
Logging.Log("Assigning " + Logging.ToString(highestPilot) + " to provide SAS");
pilotSlot.Occupant = highestPilot;
return(highestPilot.experienceLevel);
}
/// <summary>
/// As needed, assign additional crew members to fulfill part requirements.
/// </summary>
/// <param name="crewables"></param>
/// <param name="construct"></param>
private static void FulfillPartRequirements(CrewableList crewables, ShipConstruct construct)
{
// Find any professions that are required on the ship
Dictionary <string, ModuleCrewRequirement> requirements = FindRequiredProfessions(construct);
if (requirements.Count == 0)
{
return; // there aren't any requirements
}
// We can ignore any that are already provided for
List <string> ignoreList = new List <string>();
foreach (string requiredProfession in requirements.Keys)
{
int requiredLevel = requirements[requiredProfession].minimumLevel;
if (HasProfession(crewables.All, requiredProfession, requiredLevel))
{
ignoreList.Add(requiredProfession);
}
}
foreach (string ignoreProfession in ignoreList)
{
requirements.Remove(ignoreProfession);
}
if (requirements.Count == 0)
{
return; // all requirements already taken care of
}
// We now have a set of required professions that we want to have on board,
// but haven't yet satisfied. There might not be enough slots to hold them all,
// so build a prioritized list with the most-desired profession first.
List <String> prioritizedRequirements = new List <string>(requirements.Keys);
if (prioritizedRequirements.Count > 1)
{
// Sort our remaining requirements in descending order of importance
Comparison <string> byPriority = (profession1, profession2) =>
{
// First, sort by *declared* importance from the parts. i.e. if the
// Mystery Goo asks for a scientist and assigns importance 0, and the
// ISRU asks for an engineer and assigns importance 1, then the ISRU wins.
int importance1 = requirements[profession1].importance;
int importance2 = requirements[profession2].importance;
if (importance1 > importance2)
{
return(-1);
}
if (importance2 > importance1)
{
return(1);
}
// In case of a tie (e.g. one part asks for a scientist with importance 1
// and the other asks for an engineer with importance 1), then pick the
// profession that's "better".
importance1 = ProfessionImportance(profession1);
importance2 = ProfessionImportance(profession2);
if (importance1 > importance2)
{
return(-1);
}
if (importance2 > importance1)
{
return(1);
}
return(0);
};
prioritizedRequirements.Sort(byPriority);
}
// Now go through our prioritized profession requirements and try to find
// an empty slot (and available unassigned crew member) to satisfy each one.
foreach (string requiredProfession in prioritizedRequirements)
{
ModuleCrewRequirement requirement = requirements[requiredProfession];
string part = Logging.ToString(requirement.part);
ProtoCrewMember highest;
ProtoCrewMember lowest;
if (FindHighestLowestAvailable(requiredProfession, requirement.minimumLevel, crewables, out highest, out lowest))
{
// Got a crew member to fulfill the requirement. In the case of pilots,
// we want the lowest-level possible (to leave the highest freed up to
// satisfy SAS requirements for other ships). But for anyone else, we
// want the highest available.
ProtoCrewMember crew = PILOT_PROFESSION.Equals(requiredProfession) ? lowest : highest;
// Is there a command slot available?
CrewSlot slot = Crewable.FindEmptySlot(crewables.Command);
if (slot == null)
{
// okay then, how about a non-command slot?
slot = Crewable.FindEmptySlot(crewables.All);
}
if (slot == null)
{
Logging.Warn("No open slot is available to assign a " + requirement.Description + " to operate " + part);
}
else
{
slot.Occupant = crew;
Logging.Log("Assigning " + Logging.ToString(crew) + " to operate " + part);
}
}
else
{
// there's nobody to fill the slot
Logging.Warn("No " + requirement.Description + " is available to operate " + part + ", not assigning anyone");
}
} // for each required profession
}