public override bool RequirementMet(ConfiguredContract contract)
{
int level = (int)Math.Round(ScenarioUpgradeableFacilities.GetFacilityLevel(facility) *
ScenarioUpgradeableFacilities.GetFacilityLevelCount(facility)) + 1;
return level == 0 && contract != null && contract.ContractState == Contracts.Contract.State.Active ||
level >= minLevel && level <= maxLevel;
}
public override void OnLoad(ConfigNode node)
{
try
{
foreach (ConfigNode child in node.GetNodes("CONTRACT"))
{
ConfiguredContract contract = null;
try
{
contract = new ConfiguredContract();
Contract.Load(contract, child);
}
catch (Exception e)
{
LoggingUtil.LogWarning(this, "Ignored an exception while trying to load a pre-loaded contract:");
LoggingUtil.LogException(e);
}
if (contract != null && contract.contractType != null)
{
contract.preLoaded = true;
contracts.Add(contract);
}
}
}
catch (Exception e)
{
LoggingUtil.LogError(this, "Error loading ContractPreLoader from persistance file!");
LoggingUtil.LogException(e);
ExceptionLogWindow.DisplayFatalException(ExceptionLogWindow.ExceptionSituation.SCENARIO_MODULE_LOAD, e, "ContractPreLoader");
}
}
/// <summary>
/// Copy constructor.
/// </summary>
public WaypointGenerator(WaypointGenerator orig, ConfiguredContract contract)
: base()
{
foreach (WaypointData old in orig.waypoints)
{
// Copy waypoint data
for (int i = 0; i < old.count; i++)
{
WaypointData wpData = new WaypointData(old, contract);
waypoints.Add(wpData);
// Set the name
if (old.names.Any())
{
wpData.waypoint.name = (old.names.Count() == 1 ? old.names.First() : old.names.ElementAtOrDefault(i));
}
if (string.IsNullOrEmpty(wpData.waypoint.name) || wpData.waypoint.name.ToLower() == "site")
{
wpData.waypoint.name = StringUtilities.GenerateSiteName(random.Next(), wpData.waypoint.celestialBody, !wpData.waterAllowed);
}
}
}
initialized = orig.initialized;
orig.initialized = false;
this.contract = contract;
Initialize();
}
public override bool RequirementMet(ConfiguredContract contract)
{
// Perform another validation of the target body to catch late validation issues due to expressions
if (!ValidateTargetBody())
{
return false;
}
// Validate the CelestialBodySubtree exists
CelestialBodySubtree cbProgress = GetCelestialBodySubtree();
if (cbProgress == null)
{
LoggingUtil.LogError(this, ": ProgressNode for targetBody " + targetBody.bodyName + " not found.");
return false;
}
if (checkType == CheckType.MANNED)
{
return cbProgress.IsReached && cbProgress.IsCompleteManned;
}
else if (checkType == CheckType.UNMANNED)
{
return cbProgress.IsReached && cbProgress.IsCompleteUnmanned;
}
return true;
}
public override bool RequirementMet(ConfiguredContract contract)
{
foreach (string tech in techs)
{
ProtoTechNode techNode = ResearchAndDevelopment.Instance.GetTechState(tech);
if (techNode == null || techNode.state != RDTech.State.Available)
{
return false;
}
}
foreach (string partModule in partModules)
{
bool hasModule = false;
foreach (AvailablePart part in PartLoader.LoadedPartsList)
{
if (part.partPrefab == null || part.partPrefab.Modules == null)
{
continue;
}
if (ResearchAndDevelopment.PartTechAvailable(part))
{
hasModule = true;
break;
}
}
if (!hasModule)
{
return false;
}
}
foreach (string partModuleType in partModuleTypes)
{
bool hasType = false;
foreach (AvailablePart part in PartLoader.LoadedPartsList)
{
if (part.partPrefab == null || part.partPrefab.Modules == null)
{
continue;
}
if (part.partPrefab.HasValidContractObjective(partModuleType) && ResearchAndDevelopment.PartTechAvailable(part))
{
hasType = true;
break;
}
}
if (!hasType)
{
return false;
}
}
return true;
}
public override bool RequirementMet(ConfiguredContract contract)
{
// Late validation
partModuleType.All(Validation.ValidatePartModuleType);
// Actual check
return partModuleType.All(s => ProgressUtilities.HaveModuleTypeTech(s));
}
public override bool RequirementMet(ConfiguredContract contract)
{
foreach (AvailablePart part in parts)
{
if (!ResearchAndDevelopment.PartModelPurchased(part))
{
return false;
}
}
return true;
}
public override bool RequirementMet(ConfiguredContract contract)
{
// Perform another validation of the target body to catch late validation issues due to expressions
if (!ValidateTargetBody())
{
return false;
}
double coverageInPercentage = SCANsatUtil.GetCoverage(SCANsatUtil.GetSCANtype(scanType), targetBody);
return coverageInPercentage >= minCoverage && coverageInPercentage <= maxCoverage;
}
public override bool RequirementMet(ConfiguredContract contract)
{
foreach (string tech in techs)
{
ProtoTechNode techNode = ResearchAndDevelopment.Instance.GetTechState(tech);
if (techNode == null || techNode.state != RDTech.State.Available)
{
return false;
}
}
return true;
}
public override bool RequirementMet(ConfiguredContract contract)
{
bool requirementMet = true;
foreach (ContractRequirement requirement in childNodes)
{
if (requirement.enabled)
{
requirementMet &= requirement.CheckRequirement(contract);
}
}
return requirementMet;
}
public override bool RequirementMet(ConfiguredContract contract)
{
LoggingUtil.LogVerbose(this, "Checking requirement");
// Perform another validation of the target body to catch late validation issues due to expressions
if (!ValidateTargetBody())
{
return false;
}
return RemoteTechProgressTracker.Instance.ActiveRange(targetBody) > range;
}
public bool GenerateContract(ConfiguredContract contract)
{
LoggingUtil.LogVerbose(this, "Request to generate contract of prestige level " + contract.Prestige);
ConfiguredContract templateContract = GetNextContract(contract.Prestige, HighLogic.LoadedScene == GameScenes.FLIGHT);
if (templateContract == null)
{
return false;
}
// Copy the contract details
contract.CopyFrom(templateContract);
return true;
}
public override bool RequirementMet(ConfiguredContract contract)
{
// Perform another validation of the target body to catch late validation issues due to expressions
if (!ValidateTargetBody())
{
return false;
}
if (ResourceScenario.Instance == null)
{
return false;
}
return ResourceScenario.Instance.gameSettings.GetPlanetScanInfo().Where(psd => psd.PlanetId == targetBody.flightGlobalsIndex).Any();
}
public override bool RequirementMet(ConfiguredContract contract)
{
// Cache the tech tree
if (techTree == null)
{
ConfigNode techTreeRoot = ConfigNode.Load(HighLogic.CurrentGame.Parameters.Career.TechTreeUrl);
if (techTreeRoot != null)
{
techTree = techTreeRoot.GetNode("TechTree");
}
if (techTreeRoot == null || techTree == null)
{
LoggingUtil.LogError(this, "Couldn't load tech tree from " + HighLogic.CurrentGame.Parameters.Career.TechTreeUrl);
return false;
}
}
foreach (string tech in techs)
{
ConfigNode techNode = techTree.GetNodes("RDNode").Where(n => n.GetValue("id") == tech).FirstOrDefault();
if (techNode == null)
{
LoggingUtil.LogWarning(this, "No tech node found with id '" + tech + "'");
return false;
}
// Get the state of the parents, as well as the anyToUnlock flag
bool anyToUnlock = ConfigNodeUtil.ParseValue<bool>(techNode, "anyToUnlock");
IEnumerable<bool> parentsUnlocked = techNode.GetNodes("Parent").
Select(n => ResearchAndDevelopment.Instance.GetTechState(n.GetValue("parentID"))).
Select(p => p != null && p.state == RDTech.State.Available);
// Check if the parents have met the unlock criteria
if (anyToUnlock && parentsUnlocked.Any(unlocked => unlocked) ||
!anyToUnlock && parentsUnlocked.All(unlocked => unlocked))
{
continue;
}
else
{
return false;
}
}
return true;
}
public override ContractBehaviour Generate(ConfiguredContract contract)
{
// Set legacy values
if (legacy)
{
kerbals = passengerName.Select(name => new Kerbal(gender, name, experienceTrait)).ToList();
}
// Set the kerbal type
foreach (Kerbal kerbal in kerbals)
{
kerbal.kerbalType = kerbalType;
}
return new SpawnPassengers(kerbals, count);
}
/// <summary>
/// Loads a behaviour from a ConfigNode.
/// </summary>
/// <param name="configNode"></param>
/// <param name="contract"></param>
/// <returns></returns>
public static ContractBehaviour LoadBehaviour(ConfigNode configNode, ConfiguredContract contract)
{
// Determine the type
string typeName = configNode.GetValue("type");
Type type = ContractConfigurator.GetAllTypes<ContractBehaviour>().Where(t => t.FullName == typeName).FirstOrDefault();
if (type == null)
{
throw new Exception("No ContractBehaviour with type = '" + typeName + "'.");
}
// Instantiate and load
ContractBehaviour behaviour = (ContractBehaviour)Activator.CreateInstance(type);
behaviour.contract = contract;
behaviour.Load(configNode);
return behaviour;
}
public override bool RequirementMet(ConfiguredContract contract)
{
IEnumerable<ProtoCrewMember> crew = HighLogic.CurrentGame.CrewRoster.Crew;
// Filter by trait
if (trait != null)
{
crew = crew.Where<ProtoCrewMember>(cm => cm.experienceTrait.TypeName == trait);
}
// Filter by experience
crew = crew.Where<ProtoCrewMember>(cm => cm.experienceLevel >= minExperience && cm.experienceLevel <= maxExperience);
// Check counts
int count = crew.Count();
return count >= minCount && count <= maxCount;
}
public override bool RequirementMet(ConfiguredContract contract)
{
// Perform another validation of the target body to catch late validation issues due to expressions
if (!ValidateTargetBody())
{
return false;
}
// Validate the CelestialBodySubtree exists
CelestialBodySubtree cbProgress = GetCelestialBodySubtree();
if (cbProgress == null)
{
LoggingUtil.LogError(this.GetType(), ": ProgressNode for targetBody " + targetBody.bodyName + " not found.");
return false;
}
return true;
}
public override bool RequirementMet(ConfiguredContract contract)
{
int metCount = 0;
foreach (ContractRequirement requirement in childNodes)
{
if (requirement.enabled)
{
if (requirement.CheckRequirement(contract))
{
metCount++;
}
}
}
return metCount >= count;
}
public override bool RequirementMet(ConfiguredContract contract)
{
// Perform another validation of the target body to catch late validation issues due to expressions
if (!ValidateTargetBody())
{
return false;
}
if (pqsCity != null)
{
latitude = targetBody.GetLatitude(pqsCity.transform.position);
longitude = targetBody.GetLongitude(pqsCity.transform.position);
pqsCity = null;
}
return SCANsatUtil.IsCovered(latitude, longitude, SCANsatUtil.GetSCANtype(scanType), targetBody);
}
/// <summary>
/// Copy constructor.
/// </summary>
public WaypointGenerator(WaypointGenerator orig, ConfiguredContract contract)
: base()
{
foreach (WaypointData old in orig.waypoints)
{
// Copy waypoint data
for (int i = 0; i < old.count; i++)
{
waypoints.Add(new WaypointData(old, contract));
}
}
initialized = orig.initialized;
orig.initialized = false;
this.contract = contract;
Initialize();
}
/// <summary>
/// Generates all the ContractBehaviour objects required for the array of ConfigNodes, and
/// adds them to the host object.
/// </summary>
/// <param name="contract">Contract to generate behaviours for</param>
/// <param name="behaviourNodes">The behaviour factories to use</param>
/// <return>Whether generation was successful or not</return>
public static bool GenerateBehaviours(ConfiguredContract contract, List<BehaviourFactory> behaviourNodes)
{
foreach (BehaviourFactory behaviourFactory in behaviourNodes)
{
if (behaviourFactory.enabled)
{
ContractBehaviour behaviour = behaviourFactory.Generate(contract);
if (behaviour == null)
{
throw new Exception(behaviourFactory.GetType().FullName + ".Generate() returned a null ContractBehaviour!");
}
// Add ContractBehaviour to the host
contract.AddBehaviour(behaviour);
}
}
return true;
}
public override bool RequirementMet(ConfiguredContract contract)
{
LoggingUtil.LogVerbose(this, "Checking requirement");
// Perform another validation of the target body to catch late validation issues due to expressions
if (!ValidateTargetBody())
{
return false;
}
if (RemoteTechProgressTracker.Instance == null)
{
// Assume no coverage
return maxCoverage == 0.0;
}
double coverage = RemoteTechProgressTracker.GetCoverage(targetBody);
return coverage >= minCoverage && coverage <= maxCoverage;
}
public override bool RequirementMet(ConfiguredContract contract)
{
IEnumerable<UpgradeableFacility> facilities = UnityEngine.Object.FindObjectsOfType<UpgradeableFacility>().
Where<UpgradeableFacility>(f => f.name == facility);
if (facilities.Count() > 0)
{
UpgradeableFacility upgradeableFacility = facilities.First<UpgradeableFacility>();
int level = upgradeableFacility.FacilityLevel;
return level >= minLevel && level <= maxLevel;
}
else
{
// Should only get here if the facility name entered was bad
LoggingUtil.LogError(this, "Coudn't read find facility with name '" + facility + "'!");
return false;
}
}
public override void OnLoad(ConfigNode node)
{
try
{
foreach (ConfigNode child in node.GetNodes("CONTRACT"))
{
ConfiguredContract contract = new ConfiguredContract();
Contract.Load(contract, child);
contractDetails[contract.Prestige].contracts.Enqueue(contract);
}
}
catch (Exception e)
{
LoggingUtil.LogError(this, "Error loading ContractPreLoader from persistance file!");
LoggingUtil.LogException(e);
ExceptionLogWindow.DisplayFatalException(ExceptionLogWindow.ExceptionSituation.SCENARIO_MODULE_LOAD, e, "ContractPreLoader");
}
}
public override bool RequirementMet(ConfiguredContract contract)
{
foreach (string partModuleType in partModuleTypes)
{
foreach (AvailablePart part in PartLoader.LoadedPartsList)
{
if (part.partPrefab == null || part.partPrefab.Modules == null)
{
continue;
}
if (part.partPrefab.HasValidContractObjective(partModuleType) && ResearchAndDevelopment.PartTechAvailable(part) && ResearchAndDevelopment.PartModelPurchased(part))
{
return true;
}
}
}
return false;
}
public override bool RequirementMet(ConfiguredContract contract)
{
foreach (string partModule in partModules)
{
// Search for a part that has our module
bool found = false;
foreach (AvailablePart p in PartLoader.Instance.loadedParts)
{
if (p != null && p.partPrefab != null && p.partPrefab.Modules != null)
{
foreach (PartModule pm in p.partPrefab.Modules)
{
if (pm != null && pm.moduleName != null && pm.moduleName == partModule)
{
found = true;
break;
}
}
}
if (found)
{
if (ResearchAndDevelopment.PartModelPurchased(p))
{
break;
}
else
{
found = false;
}
}
}
if (!found)
{
return false;
}
}
return true;
}
public override bool RequirementMet(ConfiguredContract contract)
{
// Get the count of finished contracts
int finished = 0;
double lastFinished = 0.0;
// Finished contracts - Contract Configurator style
if (ccType != null)
{
IEnumerable<ConfiguredContract> completedContract = ContractSystem.Instance.GetCompletedContracts<ConfiguredContract>().
Where(c => c.contractType != null && c.contractType.name.Equals(ccType));
finished = completedContract.Count();
if (finished > 0)
{
// TODO - this isn't working out
lastFinished = completedContract.OrderByDescending<ConfiguredContract, double>(c => c.DateFinished).First().DateFinished;
}
}
// Finished contracts - stock style
else
{
// Call the GetCompletedContracts with our type, and get the count
Contract[] completedContract = (Contract[])typeof(ContractSystem).GetMethod("GetCompletedContracts").MakeGenericMethod(contractClass).Invoke(ContractSystem.Instance, null);
finished = completedContract.Count();
if (finished > 0)
{
lastFinished = completedContract.OrderByDescending<Contract, double>(c => c.DateFinished).First().DateFinished;
}
}
// Check cooldown
if (cooldownDuration.Value > 0.0 && finished > 0 && lastFinished + cooldownDuration.Value > Planetarium.GetUniversalTime())
{
LoggingUtil.LogDebug(this, "Returning false due to cooldown for " + contractType.name);
return false;
}
// Return based on the min/max counts configured
return (finished >= minCount) && (finished <= maxCount);
}
public override bool RequirementMet(ConfiguredContract contract)
{
// Get the count of accepted contracts
int accepted = 0;
// Finished contracts - Contract Configurator style
if (ccType != null)
{
IEnumerable<ConfiguredContract> acceptedContract = ContractSystem.Instance.Contracts.Select(c => c as ConfiguredContract).
Where(c => c != null && c.contractType != null && c.contractType.name.Equals(ccType) && c.ContractState == Contract.State.Active);
accepted = acceptedContract.Count();
}
// Finished contracts - stock style
else
{
// Call the GetCompletedContracts with our type, and get the count
IEnumerable<Contract> acceptedContract = ContractSystem.Instance.Contracts.Where(c => c != null && c.GetType() == contractClass &&
c.ContractState == Contract.State.Active);
accepted = acceptedContract.Count();
}
// Return based on the min/max counts configured
return (accepted >= minCount) && (accepted <= maxCount);
}
public override ContractBehaviour Generate(ConfiguredContract contract)
{
return new DialogBox(details);
}
