/// <summary>
/// Registers all the ContractRequirement classes.
/// </summary>
void RegisterContractRequirements()
{
LoggingUtil.LogDebug(this, "Start Registering ContractRequirements");
// Register each type
foreach (Type subclass in GetAllTypes <ContractRequirement>().Where(t => !t.IsAbstract))
{
string name = subclass.Name;
if (name.EndsWith("Requirement"))
{
name = name.Remove(name.Length - 11, 11);
}
try
{
ContractRequirement.Register(subclass, name);
}
catch (Exception e)
{
LoggingUtil.LogError(this, "Error registering contract requirement " + subclass.Name);
LoggingUtil.LogException(e);
}
}
LoggingUtil.LogInfo(this, "Finished Registering ContractRequirements");
}
/*
* Generates a ContractRequirement from a configuration node.
*/
public static ContractRequirement GenerateRequirement(ConfigNode configNode, ContractType contractType)
{
// Get the type
string type = configNode.GetValue("type");
if (!requirementTypes.ContainsKey(type))
{
LoggingUtil.LogError(typeof(ParameterFactory), "CONTRACT_TYPE '" + contractType.name + "'," +
"REQUIREMENT '" + configNode.GetValue("name") + "' of type '" + configNode.GetValue("type") + "': " +
"No ContractRequirement has been registered for type '" + type + "'.");
return(null);
}
// Create an instance of the ContractRequirement
ContractRequirement requirement = (ContractRequirement)Activator.CreateInstance(requirementTypes[type]);
// Set attributes
requirement.contractType = contractType;
requirement.targetBody = contractType.targetBody;
// Load config
bool valid = requirement.Load(configNode);
// Check for unexpected values - always do this last
valid &= ConfigNodeUtil.ValidateUnexpectedValues(configNode, requirement);
return(valid ? requirement : null);
}
/*
* Loads the ContractRequirement from the given ConfigNode. The base version loads the following:
* - child nodes
* - invertRequirement
*/
public virtual bool Load(ConfigNode configNode)
{
bool valid = true;
// Get name and type
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "name", ref name, this, "unknown");
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "type", ref type, this);
valid &= ConfigNodeUtil.ParseValue <CelestialBody>(configNode, "targetBody", ref targetBody, this, contractType.targetBody);
// By default, do not check the requirement for active contracts
valid &= ConfigNodeUtil.ParseValue <bool>(configNode, "checkOnActiveContract", ref checkOnActiveContract, this, false);
// Load invertRequirement flag
valid &= ConfigNodeUtil.ParseValue <bool>(configNode, "invertRequirement", ref invertRequirement, this, false);
// Load child nodes
childNodes = new List <ContractRequirement>();
foreach (ConfigNode childNode in configNode.GetNodes("REQUIREMENT"))
{
ContractRequirement child = ContractRequirement.GenerateRequirement(childNode, contractType);
if (child != null)
{
childNodes.Add(child);
}
else
{
valid = false;
}
}
return(valid);
}
/// <summary>
/// Loads a requirement from a ConfigNode.
/// </summary>
/// <param name="configNode"></param>
/// <param name="contract"></param>
/// <returns></returns>
public static ContractRequirement LoadRequirement(ConfigNode configNode)
{
// Determine the type
string typeName = configNode.GetValue("type");
if (string.IsNullOrEmpty(typeName))
{
return(null);
}
Type type = requirementTypes.ContainsKey(typeName) ? requirementTypes[typeName] : null;
if (type == null)
{
throw new Exception("No ContractRequirement with type = '" + typeName + "'.");
}
// Instantiate and load
ContractRequirement requirement = (ContractRequirement)Activator.CreateInstance(type);
requirement.Load(configNode);
// Load children
foreach (ConfigNode child in configNode.GetNodes("REQUIREMENT"))
{
ContractRequirement childRequirement = LoadRequirement(child);
if (childRequirement != null)
{
requirement.childNodes.Add(childRequirement);
}
}
return(requirement);
}
/*
* Returns true if the contract can be offered.
*/
public bool MeetRequirements(ConfiguredContract contract)
{
// Check prestige
if (prestige != null && contract.Prestige != prestige)
{
return(false);
}
// Get the count of active contracts - excluding ours
int activeContracts = ContractSystem.Instance.GetCurrentContracts <ConfiguredContract>().Count(c => c.contractType == this);
if (contract.ContractState == Contract.State.Offered || contract.ContractState == Contract.State.Active)
{
activeContracts--;
}
// Check if we're breaching the active limit
if (maxSimultaneous != 0 && activeContracts >= maxSimultaneous)
{
return(false);
}
// Check if we're breaching the completed limit
if (maxCompletions != 0)
{
int finishedContracts = ContractSystem.Instance.GetCompletedContracts <ConfiguredContract>().Count(c => c.contractType == this);
if (finishedContracts + activeContracts >= maxCompletions)
{
return(false);
}
}
// Check the captured requirements
return(ContractRequirement.RequirementsMet(contract, this, requirements));
}
/// <summary>
/// Method for generating ContractParameter objects. This will call the Generate() method
/// on the sub-class, load all common parameters and load child parameters.
/// </summary>
/// <param name="contract">Contract to generate for</param>
/// <param name="contractParamHost">Parent object for the ContractParameter</param>
/// <returns>Generated ContractParameter</returns>
public virtual ContractParameter Generate(ConfiguredContract contract, IContractParameterHost contractParamHost)
{
// First check any requirements
if (!ContractRequirement.RequirementsMet(contract, contract.contractType, requirements))
{
LoggingUtil.LogVerbose(typeof(ParameterFactory), "Returning null for " + contract.contractType.name + "." + name + ": requirements not met.");
return(null);
}
// Generate a parameter using the sub-class logic
ContractParameter parameter = Generate(contract);
if (parameter == null)
{
LoggingUtil.LogWarning(this, GetType().FullName + ".Generate() returned a null ContractParameter!");
return(null);
}
// Add ContractParameter to the host
contractParamHost.AddParameter(parameter);
// Set the funds/science/reputation parameters
parameter.SetFunds(rewardFunds, failureFunds, targetBody);
parameter.SetReputation(rewardReputation, failureReputation, targetBody);
parameter.SetScience(rewardScience, targetBody);
// Set other flags
parameter.Optional = optional;
if (disableOnStateChange != null)
{
parameter.DisableOnStateChange = (bool)disableOnStateChange;
}
parameter.ID = name;
// Special stuff for contract configurator parameters
ContractConfiguratorParameter ccParam = parameter as ContractConfiguratorParameter;
if (ccParam != null)
{
ccParam.completeInSequence = completeInSequence;
ccParam.notes = notes;
ccParam.completedMessage = completedMessage;
ccParam.hidden = hidden;
ccParam.hideChildren = hideChildren;
}
return(parameter);
}
/// <summary>
/// Forced check of contract requirement and its children.
/// </summary>
static void CheckRequirement(ContractRequirement requirement)
{
try
{
requirement.lastResult = requirement.invertRequirement ^ requirement.RequirementMet(null);
}
catch (Exception e)
{
Debug.LogException(e);
}
foreach (ContractRequirement child in requirement.ChildRequirements)
{
CheckRequirement(child);
}
}
/// <summary>
/// Registers all the ContractRequirement classes.
/// </summary>
void RegisterContractRequirements()
{
LoggingUtil.LogDebug(this.GetType(), "Start Registering ContractRequirements");
// Register each type with the parameter factory
foreach (Type subclass in GetAllTypes <ContractRequirement>())
{
string name = subclass.Name;
if (name.EndsWith("Requirement"))
{
name = name.Remove(name.Length - 11, 11);
}
ContractRequirement.Register(subclass, name);
}
LoggingUtil.LogInfo(this.GetType(), "Finished Registering ContractRequirements");
}
/// <summary>
/// Loads the contract type details from the given config node.
/// </summary>
/// <param name="configNode">The config node to load from.</param>
/// <returns>Whether the load was successful.</returns>
public bool Load(ConfigNode configNode)
{
LoggingUtil.LogLevel origLogLevel = LoggingUtil.logLevel;
try
{
// Logging on
LoggingUtil.CaptureLog = true;
ConfigNodeUtil.SetCurrentDataNode(null);
LoggingUtil.LogInfo(this, "Loading CONTRACT_TYPE: '" + name + "'");
// Clear the config node cache
ConfigNodeUtil.ClearCache(true);
// Load values that are immediately required
bool valid = true;
valid &= ConfigNodeUtil.ParseValue <ContractGroup>(configNode, "group", x => group = x, this, (ContractGroup)null);
// Set up the data node
dataNode = new DataNode(configNode.GetValue("name"), group != null ? group.dataNode : null, this);
ConfigNodeUtil.SetCurrentDataNode(dataNode);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "name", x => name = x, this);
// Try to turn on trace mode
valid &= ConfigNodeUtil.ParseValue <bool>(configNode, "trace", x => trace = x, this, false);
if (trace)
{
LoggingUtil.logLevel = LoggingUtil.LogLevel.VERBOSE;
LoggingUtil.LogWarning(this, "Tracing enabled for contract type " + name);
}
// Load contract text details
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "title", x => title = x, this);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "tag", x => tag = x, this, "");
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "description", x => description = x, this, (string)null);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "topic", x => topic = x, this, "");
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "subject", x => subject = x, this, "");
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "notes", x => notes = x, this, (string)null);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "synopsis", x => synopsis = x, this);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "completedMessage", x => completedMessage = x, this);
if (configNode.HasValue("motivation)"))
{
string motivation;
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "motivation", x => motivation = x, this, "");
LoggingUtil.LogWarning(this, "The 'motivation' attribute is no longer supported as of Contract Configurator 1.23.0");
}
// Load optional attributes
valid &= ConfigNodeUtil.ParseValue <Agent>(configNode, "agent", x => agent = x, this, group != null ? group.agent : null);
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "minExpiry", x => minExpiry = x, this, 5.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "maxExpiry", x => maxExpiry = x, this, 100.0f, x => Validation.GE(x, minExpiry));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "deadline", x => deadline = x, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <bool>(configNode, "cancellable", x => cancellable = x, this, true);
valid &= ConfigNodeUtil.ParseValue <bool>(configNode, "declinable", x => declinable = x, this, true);
valid &= ConfigNodeUtil.ParseValue <bool>(configNode, "autoAccept", x => autoAccept = x, this, false);
valid &= ConfigNodeUtil.ParseValue <List <Contract.ContractPrestige> >(configNode, "prestige", x => prestige = x, this, new List <Contract.ContractPrestige>());
valid &= ConfigNodeUtil.ParseValue <CelestialBody>(configNode, "targetBody", x => targetBody = x, this, (CelestialBody)null);
valid &= ConfigNodeUtil.ParseValue <int>(configNode, "maxCompletions", x => maxCompletions = x, this, 0, x => Validation.GE(x, 0));
valid &= ConfigNodeUtil.ParseValue <int>(configNode, "maxSimultaneous", x => maxSimultaneous = x, this, (maxCompletions == 0 ? 4 : 0), x => Validation.GE(x, 0));
// Load rewards
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "rewardFunds", x => rewardFunds = x, this, 0.0f);
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "rewardReputation", x => rewardReputation = x, this, 0.0f);
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "rewardScience", x => rewardScience = x, this, 0.0f);
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "failureFunds", x => failureFunds = x, this, 0.0f);
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "failureReputation", x => failureReputation = x, this, 0.0f);
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "advanceFunds", x => advanceFunds = x, this, 0.0f);
// Load other values
if (configNode.HasValue("weight"))
{
double weight;
valid &= ConfigNodeUtil.ParseValue <double>(configNode, "weight", x => weight = x, this);
LoggingUtil.LogWarning(this, ErrorPrefix() + ": The weight attribute is deprecated as of Contract Configurator 1.15.0. Contracts are no longer generated using a weighted system.");
}
// Merge in data from the parent contract group
for (ContractGroup currentGroup = group; currentGroup != null; currentGroup = currentGroup.parent)
{
// Merge dataValues - this is a flag saying what values need to be unique at the contract level
foreach (KeyValuePair <string, DataValueInfo> pair in currentGroup.dataValues)
{
dataValues[currentGroup.name + ":" + pair.Key] = pair.Value;
}
// Merge uniquenessChecks
foreach (KeyValuePair <string, DataNode.UniquenessCheck> pair in currentGroup.uniquenessChecks)
{
uniquenessChecks[currentGroup.name + ":" + pair.Key] = pair.Value;
}
}
// Load DATA nodes
valid &= dataNode.ParseDataNodes(configNode, this, dataValues, uniquenessChecks);
log = LoggingUtil.capturedLog;
LoggingUtil.CaptureLog = false;
// Load parameters
foreach (ConfigNode contractParameter in ConfigNodeUtil.GetChildNodes(configNode, "PARAMETER"))
{
ParameterFactory paramFactory = null;
valid &= ParameterFactory.GenerateParameterFactory(contractParameter, this, out paramFactory);
if (paramFactory != null)
{
paramFactories.Add(paramFactory);
if (paramFactory.hasWarnings)
{
hasWarnings = true;
}
}
}
// Load behaviours
foreach (ConfigNode requirementNode in ConfigNodeUtil.GetChildNodes(configNode, "BEHAVIOUR"))
{
BehaviourFactory behaviourFactory = null;
valid &= BehaviourFactory.GenerateBehaviourFactory(requirementNode, this, out behaviourFactory);
if (behaviourFactory != null)
{
behaviourFactories.Add(behaviourFactory);
if (behaviourFactory.hasWarnings)
{
hasWarnings = true;
}
}
}
// Load requirements
foreach (ConfigNode requirementNode in ConfigNodeUtil.GetChildNodes(configNode, "REQUIREMENT"))
{
ContractRequirement requirement = null;
valid &= ContractRequirement.GenerateRequirement(requirementNode, this, out requirement);
if (requirement != null)
{
requirements.Add(requirement);
if (requirement.hasWarnings)
{
hasWarnings = true;
}
}
}
// Logging on
LoggingUtil.CaptureLog = true;
// Check we have at least one valid parameter
if (paramFactories.Count() == 0)
{
LoggingUtil.LogError(this, ErrorPrefix() + ": Need at least one parameter for a contract!");
valid = false;
}
ConfigNodeUtil.SetCurrentDataNode(dataNode);
//
// Process the DATA_EXPAND nodes - this could cause a restart to the load process
//
ConfigNode dataExpandNode = configNode.GetNodes("DATA_EXPAND").FirstOrDefault();
if (dataExpandNode != null)
{
Type type = null;
valid &= ConfigNodeUtil.ParseValue <Type>(dataExpandNode, "type", x => type = x, this);
if (type != null)
{
foreach (ConfigNode.Value pair in dataExpandNode.values)
{
string key = pair.name;
if (key != "type")
{
object value = null;
// Create the setter function
Type actionType = typeof(Action <>).MakeGenericType(type);
Delegate del = Delegate.CreateDelegate(actionType, value, typeof(DataNode).GetMethod("NullAction"));
// Set the ParseDataExpandString method generic value
MethodInfo method = methodParseExpand.MakeGenericMethod(new Type[] { type });
// Invoke the ParseDataExpandString method
List <string> values = (List <string>)method.Invoke(this, new object[] { dataExpandNode, key });
// Stop at this point if we're invalid
if (values == null || !valid)
{
if (values == null)
{
LoggingUtil.LogWarning(this, ErrorPrefix() + ": Received an empty list of values when trying to do a DATA_EXPAND");
}
valid = false;
break;
}
// Expand
configNode.RemoveNode(dataExpandNode);
foreach (string val in values)
{
// Set up for expansion
ConfigNode copy = configNode.CreateCopy();
string newName = name + "." + val;
copy.SetValue("name", newName);
// Set up the data node in the copy
ConfigNode dataNode = new ConfigNode("DATA");
copy.AddNode(dataNode);
dataNode.AddValue("type", dataExpandNode.GetValue("type"));
dataNode.AddValue(key, val);
ContractType contractTypeCopy = new ContractType(newName);
contractTypeCopy.Load(copy);
}
// Remove the original
contractTypes.Remove(name);
// Don't do any more loading for this one
LoggingUtil.LogInfo(this, "Successfully expanded CONTRACT_TYPE '" + name + "'");
return(valid);
}
}
}
}
//
// Do the deferred loads
//
valid &= ConfigNodeUtil.ExecuteDeferredLoads();
//
// Do generic fields that need to happen after deferred loads
//
ConfigNodeUtil.SetCurrentDataNode(dataNode);
// Generic title
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "genericTitle", x => genericTitle = x, this, title);
if (!configNode.HasValue("genericTitle") && !dataNode.IsDeterministic("title"))
{
LoggingUtil.Log(minVersion >= ContractConfigurator.ENHANCED_UI_VERSION ? LoggingUtil.LogLevel.ERROR : LoggingUtil.LogLevel.WARNING, this,
ErrorPrefix() + ": The field 'genericTitle' is required when the title is not determistic (ie. when expressions are used).");
// Error on newer versions of contract packs
if (minVersion >= ContractConfigurator.ENHANCED_UI_VERSION)
{
valid = false;
}
}
else if (!dataNode.IsDeterministic("genericTitle"))
{
valid = false;
LoggingUtil.LogError(this, ErrorPrefix() + ": The field 'genericTitle' must be deterministic.");
}
// Generic description
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "genericDescription", x => genericDescription = x, this, description);
if (!configNode.HasValue("genericDescription") && !dataNode.IsDeterministic("description"))
{
LoggingUtil.Log(minVersion >= ContractConfigurator.ENHANCED_UI_VERSION ? LoggingUtil.LogLevel.ERROR : LoggingUtil.LogLevel.WARNING, this,
ErrorPrefix() + ": The field 'genericDescription' is required when the description is not determistic (ie. when expressions are used).");
// Error on newer versions of contract packs
if (minVersion >= ContractConfigurator.ENHANCED_UI_VERSION)
{
valid = false;
}
}
else if (!dataNode.IsDeterministic("genericDescription"))
{
valid = false;
LoggingUtil.LogError(this, ErrorPrefix() + ": The field 'genericDescription' must be deterministic.");
}
// Sorting key
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "sortKey", x => sortKey = x, this, genericTitle);
// Check for unexpected values - always do this last
valid &= ConfigNodeUtil.ValidateUnexpectedValues(configNode, this);
if (valid)
{
LoggingUtil.LogInfo(this, "Successfully loaded CONTRACT_TYPE '" + name + "'");
}
else
{
LoggingUtil.LogWarning(this, "Errors encountered while trying to load CONTRACT_TYPE '" + name + "'");
}
config = configNode.ToString();
hash = config.GetHashCode();
enabled = valid;
log += LoggingUtil.capturedLog;
if (LoggingUtil.logLevel >= LoggingUtil.LogLevel.DEBUG)
{
// Get the contract configurator log file
string[] dirComponents = new string[] { KSPUtil.ApplicationRootPath, "GameData", "ContractConfigurator", "log", (group == null ? "!NO_GROUP" : group.Root.name) };
string[] pathComponents = dirComponents.Union(new string[] { name + ".log" }).ToArray();
string dir = string.Join(Path.DirectorySeparatorChar.ToString(), dirComponents);
string path = string.Join(Path.DirectorySeparatorChar.ToString(), pathComponents);
// Delete the file if it exists
if (File.Exists(path))
{
try
{
File.Delete(path);
}
catch (Exception e)
{
LoggingUtil.LogException(new Exception("Exception while attempting to delete the file: " + path, e));
}
}
// Create the directory if it doesn't exist
Directory.CreateDirectory(dir);
// Now write the config and the cleaned up log to it
try
{
using (StreamWriter sw = File.AppendText(path))
{
sw.Write("Debug information for CONTRACT_TYPE '" + name + "':\n");
sw.Write("\nConfiguration:\n");
sw.Write(config);
sw.Write("\nData Nodes:\n");
sw.Write(DataNodeDebug(dataNode));
sw.Write("\nOutput log:\n");
sw.Write(log);
}
}
catch
{
LoggingUtil.LogError(this, "Exception while attempting to write to the file: " + path);
}
}
return(valid);
}
catch (Exception e)
{
enabled = false;
throw new Exception("Error loading CONTRACT_TYPE '" + name + "'", e);
}
finally
{
LoggingUtil.CaptureLog = false;
LoggingUtil.logLevel = origLogLevel;
loaded = true;
}
}
/// <summary>
/// Checks if the "extended" requirements that change due to expressions.
/// </summary>
/// <param name="contract">The contract</param>
/// <returns>Whether the contract can be offered.</returns>
public bool MeetExtendedRequirements(ConfiguredContract contract, ContractType contractType)
{
LoggingUtil.LogLevel origLogLevel = LoggingUtil.logLevel;
try
{
// Turn tracing on
if (trace)
{
LoggingUtil.logLevel = LoggingUtil.LogLevel.VERBOSE;
LoggingUtil.LogWarning(this, "Tracing enabled for contract type " + name);
}
// Hash check
if (contract.ContractState == Contract.State.Offered && contract.hash != hash)
{
throw new ContractRequirementException("Contract definition changed.");
}
// Check prestige
if (prestige.Count > 0 && !prestige.Contains(contract.Prestige))
{
throw new ContractRequirementException("Wrong prestige level.");
}
// Do a Research Bodies check, if applicable
ResearchBodiesCheck(contract);
// Check special values are not null
if (contract.contractType == null)
{
foreach (KeyValuePair <string, DataValueInfo> pair in dataValues)
{
// Only check if it is a required value
if (pair.Value.required)
{
CheckRequiredValue(pair.Key);
}
}
}
if (contract.contractType == null || contract.ContractState == Contract.State.Generated || contract.ContractState == Contract.State.Withdrawn)
{
// Check for unique values against other contracts of the same type
foreach (KeyValuePair <string, DataNode.UniquenessCheck> pair in uniquenessChecks.Where(p => contract.uniqueData.ContainsKey(p.Key)))
{
string key = pair.Key;
DataNode.UniquenessCheck uniquenessCheck = pair.Value;
LoggingUtil.LogVerbose(this, "Doing unique value check for " + key);
// Get the active/offered contract lists
IEnumerable <ConfiguredContract> contractList = ConfiguredContract.CurrentContracts.
Where(c => c != null && c.contractType != null && c != contract);
// Add in finished contracts
if (uniquenessCheck == DataNode.UniquenessCheck.CONTRACT_ALL || uniquenessCheck == DataNode.UniquenessCheck.GROUP_ALL)
{
contractList = contractList.Union(ContractSystem.Instance.ContractsFinished.OfType <ConfiguredContract>().
Where(c => c != null && c.contractType != null && c != contract));
}
// Filter anything that doesn't have our key
contractList = contractList.Where(c => c.uniqueData.ContainsKey(key));
// Check for contracts of the same type
if (uniquenessCheck == DataNode.UniquenessCheck.CONTRACT_ALL || uniquenessCheck == DataNode.UniquenessCheck.CONTRACT_ACTIVE)
{
contractList = contractList.Where(c => c.contractType.name == name);
}
// Check for a shared group
else if (contractType.group != null)
{
contractList = contractList.Where(c => c.contractType.group != null && c.contractType.group.name == contractType.group.name);
}
// Shared lack of group
else
{
contractList = contractList.Where(c => c.contractType.group == null);
}
object val = contract.uniqueData[key];
if (val != null)
{
// Special case for vessels - convert to the Guid
Vessel vessel = val as Vessel;
if (vessel != null)
{
val = vessel.id;
}
foreach (ConfiguredContract otherContract in contractList)
{
if (val.Equals(otherContract.uniqueData[key]))
{
throw new ContractRequirementException("Failed on unique value check for key '" + key + "'.");
}
}
}
}
}
// Check the captured requirements
if (!ContractRequirement.RequirementsMet(contract, this, contract.requirements != null ? contract.requirements : requirements))
{
throw new ContractRequirementException("Failed on contract requirement check.");
}
return(true);
}
catch (ContractRequirementException e)
{
LoggingUtil.LogLevel level = contract.ContractState == Contract.State.Active ? LoggingUtil.LogLevel.INFO : contract.contractType != null ? LoggingUtil.LogLevel.DEBUG : LoggingUtil.LogLevel.VERBOSE;
string prefix = contract.contractType != null ? "Cancelling contract of type " + name + " (" + contract.Title + "): " :
"Didn't generate contract of type " + name + ": ";
LoggingUtil.Log(level, this.GetType(), prefix + e.Message);
return(false);
}
catch
{
LoggingUtil.LogError(this, "Exception while attempting to check requirements of contract type " + name);
throw;
}
finally
{
LoggingUtil.logLevel = origLogLevel;
loaded = true;
}
}
/// <summary>
/// Generates a ContractRequirement from a configuration node.
/// </summary>
/// <param name="configNode">ConfigNode to use in the generation.</param>
/// <param name="contractType">ContractType that this requirement falls under</param>
/// <param name="requirement">The ContractRequirement object.</param>
/// <returns>Whether the load was successful</returns>
public static bool GenerateRequirement(ConfigNode configNode, ContractType contractType, out ContractRequirement requirement,
IContractConfiguratorFactory parent = null)
{
// Logging on
LoggingUtil.CaptureLog = true;
bool valid = true;
// Get the type
string type = configNode.GetValue("type");
string name = configNode.HasValue("name") ? configNode.GetValue("name") : type;
if (string.IsNullOrEmpty(type))
{
LoggingUtil.LogError(typeof(ParameterFactory), "CONTRACT_TYPE '" + contractType.name + "'," +
"REQUIREMENT '" + configNode.GetValue("name") + "' does not specify the mandatory 'type' attribute.");
requirement = new InvalidContractRequirement();
valid = false;
}
else if (!requirementTypes.ContainsKey(type))
{
LoggingUtil.LogError(typeof(ParameterFactory), "CONTRACT_TYPE '" + contractType.name + "'," +
"REQUIREMENT '" + configNode.GetValue("name") + "' of type '" + configNode.GetValue("type") + "': " +
"No ContractRequirement has been registered for type '" + type + "'.");
requirement = new InvalidContractRequirement();
valid = false;
}
else
{
// Create an instance of the ContractRequirement
requirement = (ContractRequirement)Activator.CreateInstance(requirementTypes[type]);
}
// Set attributes
requirement.contractType = contractType;
requirement.dataNode = new DataNode(name, parent != null ? parent.dataNode : contractType.dataNode, requirement);
// Load config
valid &= requirement.Load(configNode);
// Check for unexpected values - always do this last
if (requirement.GetType() != typeof(InvalidContractRequirement))
{
valid &= ConfigNodeUtil.ValidateUnexpectedValues(configNode, requirement);
}
// Load child nodes
foreach (ConfigNode childNode in ConfigNodeUtil.GetChildNodes(configNode, "REQUIREMENT"))
{
ContractRequirement child = null;
valid &= ContractRequirement.GenerateRequirement(childNode, contractType, out child, requirement);
if (child != null)
{
requirement.childNodes.Add(child);
if (child.hasWarnings)
{
requirement.hasWarnings = true;
}
}
}
requirement.enabled = valid;
requirement.log = LoggingUtil.capturedLog;
LoggingUtil.CaptureLog = false;
return(valid);
}
/// <summary>
/// Generates a ContractRequirement from a configuration node.
/// </summary>
/// <param name="configNode">ConfigNode to use in the generation.</param>
/// <param name="contractType">ContractType that this requirement falls under</param>
/// <param name="requirement">The ContractRequirement object.</param>
/// <returns>Whether the load was successful</returns>
public static bool GenerateRequirement(ConfigNode configNode, ContractType contractType, out ContractRequirement requirement,
IContractConfiguratorFactory parent = null)
{
// Logging on
LoggingUtil.CaptureLog = true;
bool valid = true;
// Get the type
string type = configNode.GetValue("type");
string name = configNode.HasValue("name") ? configNode.GetValue("name") : type;
if (string.IsNullOrEmpty(type))
{
LoggingUtil.LogError(typeof(ParameterFactory), "CONTRACT_TYPE '" + contractType.name + "'," +
"REQUIREMENT '" + configNode.GetValue("name") + "' does not specify the mandatory 'type' attribute.");
requirement = new InvalidContractRequirement();
valid = false;
}
else if (!requirementTypes.ContainsKey(type))
{
LoggingUtil.LogError(typeof(ParameterFactory), "CONTRACT_TYPE '" + contractType.name + "'," +
"REQUIREMENT '" + configNode.GetValue("name") + "' of type '" + configNode.GetValue("type") + "': " +
"Unknown requirement '" + type + "'.");
requirement = new InvalidContractRequirement();
valid = false;
}
else
{
// Create an instance of the ContractRequirement
requirement = (ContractRequirement)Activator.CreateInstance(requirementTypes[type]);
}
// Set attributes
requirement.contractType = contractType;
requirement.dataNode = new DataNode(name, parent != null ? parent.dataNode : contractType.dataNode, requirement);
// Load config
valid &= requirement.Load(configNode);
// Check for unexpected values - always do this last
if (requirement.GetType() != typeof(InvalidContractRequirement))
{
valid &= ConfigNodeUtil.ValidateUnexpectedValues(configNode, requirement);
}
// Load child nodes
foreach (ConfigNode childNode in ConfigNodeUtil.GetChildNodes(configNode, "REQUIREMENT"))
{
ContractRequirement child = null;
valid &= ContractRequirement.GenerateRequirement(childNode, contractType, out child, requirement);
if (child != null)
{
requirement.childNodes.Add(child);
if (child.hasWarnings)
{
requirement.hasWarnings = true;
}
}
}
requirement.enabled = valid;
requirement.log = LoggingUtil.capturedLog;
LoggingUtil.CaptureLog = false;
return valid;
}
/// <summary>
/// Forced check of contract requirement and its children.
/// </summary>
static void CheckRequirement(ContractRequirement requirement)
{
try
{
requirement.lastResult = requirement.invertRequirement ^ requirement.RequirementMet(null);
}
catch (Exception e)
{
Debug.LogException(e);
}
foreach (ContractRequirement child in requirement.ChildRequirements)
{
CheckRequirement(child);
}
}
/// <summary>
/// Loads the contract type details from the given config node.
/// </summary>
/// <param name="configNode">The config node to load from.</param>
/// <returns>Whether the load was successful.</returns>
public bool Load(ConfigNode configNode)
{
try
{
// Logging on
LoggingUtil.CaptureLog = true;
dataNode = new DataNode(configNode.GetValue("name"), this);
ConfigNodeUtil.ClearCache(true);
ConfigNodeUtil.SetCurrentDataNode(dataNode);
bool valid = true;
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "name", x => name = x, this);
// Load contract text details
valid &= ConfigNodeUtil.ParseValue <ContractGroup>(configNode, "group", x => group = x, this, (ContractGroup)null);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "title", x => title = x, this);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "tag", x => tag = x, this, "");
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "description", x => description = x, this, (string)null);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "topic", x => topic = x, this, (string)null);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "subject", x => subject = x, this, (string)null);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "motivation", x => motivation = x, this, (string)null);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "notes", x => notes = x, this, (string)null);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "synopsis", x => synopsis = x, this);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "completedMessage", x => completedMessage = x, this);
// Load optional attributes
valid &= ConfigNodeUtil.ParseValue <Agent>(configNode, "agent", x => agent = x, this, (Agent)null);
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "minExpiry", x => minExpiry = x, this, 1.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "maxExpiry", x => maxExpiry = x, this, 7.0f, x => Validation.GE(x, minExpiry));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "deadline", x => deadline = x, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <bool>(configNode, "cancellable", x => cancellable = x, this, true);
valid &= ConfigNodeUtil.ParseValue <bool>(configNode, "declinable", x => declinable = x, this, true);
valid &= ConfigNodeUtil.ParseValue <List <Contract.ContractPrestige> >(configNode, "prestige", x => prestige = x, this, new List <Contract.ContractPrestige>());
valid &= ConfigNodeUtil.ParseValue <CelestialBody>(configNode, "targetBody", x => targetBody = x, this, (CelestialBody)null);
valid &= ConfigNodeUtil.ParseValue <int>(configNode, "maxCompletions", x => maxCompletions = x, this, 0, x => Validation.GE(x, 0));
valid &= ConfigNodeUtil.ParseValue <int>(configNode, "maxSimultaneous", x => maxSimultaneous = x, this, 0, x => Validation.GE(x, 0));
// Load rewards
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "rewardFunds", x => rewardFunds = x, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "rewardReputation", x => rewardReputation = x, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "rewardScience", x => rewardScience = x, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "failureFunds", x => failureFunds = x, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "failureReputation", x => failureReputation = x, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "advanceFunds", x => advanceFunds = x, this, 0.0f, x => Validation.GE(x, 0.0f));
// Load other values
valid &= ConfigNodeUtil.ParseValue <double>(configNode, "weight", x => weight = x, this, 1.0, x => Validation.GE(x, 0.0f));
// TODO - these are to be deprecated
if (configNode.HasValue("targetBodies"))
{
valid &= ConfigNodeUtil.ParseValue <List <CelestialBody> >(configNode, "targetBodies", x => targetBodies = x, this, new List <CelestialBody>());
LoggingUtil.LogWarning(this, "The 'targetBodies' attribute is obsolete as of Contract Configurator 0.7.4. It will be removed in 1.0.0 in favour of the DATA { } node.");
}
if (configNode.HasValue("targetVessel"))
{
valid &= ConfigNodeUtil.ParseValue <Vessel>(configNode, "targetVessel", x => targetVessel = x, this, (Vessel)null);
LoggingUtil.LogWarning(this, "The 'targetVessel' attribute is obsolete as of Contract Configurator 0.7.4. It will be removed in 1.0.0 in favour of the DATA { } node.");
}
if (configNode.HasValue("targetVessels"))
{
valid &= ConfigNodeUtil.ParseValue <List <Vessel> >(configNode, "targetVessels", x => targetVessels = x, this, new List <Vessel>());
LoggingUtil.LogWarning(this, "The 'targetVessels' attribute is obsolete as of Contract Configurator 0.7.4. It will be removed in 1.0.0 in favour of the DATA { } node.");
}
if (configNode.HasValue("targetKerbal"))
{
valid &= ConfigNodeUtil.ParseValue <Kerbal>(configNode, "targetKerbal", x => targetKerbal = x, this, (Kerbal)null);
LoggingUtil.LogWarning(this, "The 'targetKerbal' attribute is obsolete as of Contract Configurator 0.7.4. It will be removed in 1.0.0 in favour of the DATA { } node.");
}
if (configNode.HasValue("targetKerbals"))
{
valid &= ConfigNodeUtil.ParseValue <List <Kerbal> >(configNode, "targetKerbals", x => targetKerbals = x, this, new List <Kerbal>());
LoggingUtil.LogWarning(this, "The 'targetKerbals' attribute is obsolete as of Contract Configurator 0.7.4. It will be removed in 1.0.0 in favour of the DATA { } node.");
}
// Load DATA nodes
foreach (ConfigNode data in ConfigNodeUtil.GetChildNodes(configNode, "DATA"))
{
Type type = null;
bool requiredValue = true;
valid &= ConfigNodeUtil.ParseValue <Type>(data, "type", x => type = x, this);
valid &= ConfigNodeUtil.ParseValue <bool>(data, "requiredValue", x => requiredValue = x, this, true);
if (type != null)
{
foreach (ConfigNode.Value pair in data.values)
{
string name = pair.name;
if (name != "type" && name != "requiredValue")
{
object value = null;
// Create the setter function
Type actionType = typeof(Action <>).MakeGenericType(type);
Delegate del = Delegate.CreateDelegate(actionType, value, typeof(ContractType).GetMethod("NullAction"));
// Get the ParseValue method
MethodInfo method = typeof(ConfigNodeUtil).GetMethods(BindingFlags.Static | BindingFlags.Public).
Where(m => m.Name == "ParseValue" && m.GetParameters().Count() == 4).Single();
method = method.MakeGenericMethod(new Type[] { type });
// Invoke the ParseValue method
valid &= (bool)method.Invoke(null, new object[] { data, name, del, this });
dataValues[name] = requiredValue;
}
}
}
}
// Check for unexpected values - always do this last
valid &= ConfigNodeUtil.ValidateUnexpectedValues(configNode, this);
log = LoggingUtil.capturedLog;
LoggingUtil.CaptureLog = false;
// Load parameters
foreach (ConfigNode contractParameter in ConfigNodeUtil.GetChildNodes(configNode, "PARAMETER"))
{
ParameterFactory paramFactory = null;
valid &= ParameterFactory.GenerateParameterFactory(contractParameter, this, out paramFactory);
if (paramFactory != null)
{
paramFactories.Add(paramFactory);
if (paramFactory.hasWarnings)
{
hasWarnings = true;
}
}
}
// Load behaviours
foreach (ConfigNode requirementNode in ConfigNodeUtil.GetChildNodes(configNode, "BEHAVIOUR"))
{
BehaviourFactory behaviourFactory = null;
valid &= BehaviourFactory.GenerateBehaviourFactory(requirementNode, this, out behaviourFactory);
if (behaviourFactory != null)
{
behaviourFactories.Add(behaviourFactory);
if (behaviourFactory.hasWarnings)
{
hasWarnings = true;
}
}
}
// Load requirements
foreach (ConfigNode requirementNode in ConfigNodeUtil.GetChildNodes(configNode, "REQUIREMENT"))
{
ContractRequirement requirement = null;
valid &= ContractRequirement.GenerateRequirement(requirementNode, this, out requirement);
if (requirement != null)
{
requirements.Add(requirement);
if (requirement.hasWarnings)
{
hasWarnings = true;
}
}
}
// Logging on
LoggingUtil.CaptureLog = true;
// Check we have at least one valid parameter
if (paramFactories.Count() == 0)
{
LoggingUtil.LogError(this.GetType(), ErrorPrefix() + ": Need at least one parameter for a contract!");
valid = false;
}
// Do the deferred loads
valid &= ConfigNodeUtil.ExecuteDeferredLoads();
config = configNode.ToString();
hash = config.GetHashCode();
enabled = valid;
log += LoggingUtil.capturedLog;
LoggingUtil.CaptureLog = false;
return(valid);
}
catch
{
enabled = false;
throw;
}
}
protected override void OnLoad(ConfigNode node)
{
try
{
subType = node.GetValue("subtype");
contractType = ContractType.GetContractType(subType);
title = ConfigNodeUtil.ParseValue <string>(node, "title", contractType != null ? contractType.title : subType);
description = ConfigNodeUtil.ParseValue <string>(node, "description", contractType != null ? contractType.description : "");
synopsis = ConfigNodeUtil.ParseValue <string>(node, "synopsis", contractType != null ? contractType.synopsis : "");
completedMessage = ConfigNodeUtil.ParseValue <string>(node, "completedMessage", contractType != null ? contractType.completedMessage : "");
notes = ConfigNodeUtil.ParseValue <string>(node, "notes", contractType != null ? contractType.notes : "");
hash = ConfigNodeUtil.ParseValue <int>(node, "hash", contractType != null ? contractType.hash : 0);
targetBody = ConfigNodeUtil.ParseValue <CelestialBody>(node, "targetBody", null);
// Load the unique data
ConfigNode dataNode = node.GetNode("UNIQUE_DATA");
if (dataNode != null)
{
// Handle individual values
foreach (ConfigNode.Value pair in dataNode.values)
{
string typeName = pair.value.Remove(pair.value.IndexOf(":"));
string value = pair.value.Substring(typeName.Length + 1);
Type type = ConfigNodeUtil.ParseTypeValue(typeName);
// Prevents issues with vessels not getting loaded in some scenes (ie. VAB)
if (type == typeof(Vessel))
{
type = typeof(Guid);
}
if (type == typeof(string))
{
uniqueData[pair.name] = value;
}
else
{
// Get the ParseValue method
MethodInfo parseValueMethod = typeof(ConfigNodeUtil).GetMethods().Where(m => m.Name == "ParseSingleValue").Single();
parseValueMethod = parseValueMethod.MakeGenericMethod(new Type[] { type });
// Invoke the ParseValue method
uniqueData[pair.name] = parseValueMethod.Invoke(null, new object[] { pair.name, value, false });
}
}
}
foreach (ConfigNode child in node.GetNodes("BEHAVIOUR"))
{
ContractBehaviour behaviour = ContractBehaviour.LoadBehaviour(child, this);
behaviours.Add(behaviour);
}
foreach (ConfigNode child in node.GetNodes("REQUIREMENT"))
{
ContractRequirement requirement = ContractRequirement.LoadRequirement(child);
requirements.Add(requirement);
}
// If the contract type is null, then it likely means that it was uninstalled
if (contractType == null)
{
LoggingUtil.LogWarning(this, "Error loading contract for contract type '" + subType +
"'. The contract type either failed to load or was uninstalled.");
try
{
if (ContractState == State.Active || ContractState == State.Offered)
{
SetState(ContractState == State.Active ? State.Failed : State.Withdrawn);
}
}
catch { }
return;
}
OnContractLoaded.Fire(this);
}
catch (Exception e)
{
LoggingUtil.LogError(this, "Error loading contract from persistance file!");
LoggingUtil.LogException(e);
ExceptionLogWindow.DisplayFatalException(ExceptionLogWindow.ExceptionSituation.CONTRACT_LOAD, e, this);
try
{
SetState(State.Failed);
}
catch { }
}
}
/*
* Loads the contract type details from the given config node.
*/
public bool Load(ConfigNode configNode)
{
ConfigNodeUtil.ClearFoundCache();
bool valid = true;
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "name", ref name, this);
// Load contract text details
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "title", ref title, this);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "description", ref description, this, (string)null);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "topic", ref topic, this, (string)null);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "subject", ref subject, this, (string)null);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "motivation", ref motivation, this, (string)null);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "notes", ref notes, this, (string)null);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "synopsis", ref synopsis, this);
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "completedMessage", ref completedMessage, this);
// Load optional attributes
valid &= ConfigNodeUtil.ParseValue <Agent>(configNode, "agent", ref agent, this, (Agent)null);
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "minExpiry", ref minExpiry, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "maxExpiry", ref maxExpiry, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "deadline", ref deadline, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <bool>(configNode, "cancellable", ref cancellable, this, true);
valid &= ConfigNodeUtil.ParseValue <bool>(configNode, "declinable", ref declinable, this, true);
valid &= ConfigNodeUtil.ParseValue <Contract.ContractPrestige?>(configNode, "prestige", ref prestige, this, (Contract.ContractPrestige?)null);
valid &= ConfigNodeUtil.ParseValue <CelestialBody>(configNode, "targetBody", ref targetBody, this, (CelestialBody)null);
valid &= ConfigNodeUtil.ParseValue <int>(configNode, "maxCompletions", ref maxCompletions, this, 0, x => Validation.GE(x, 0));
valid &= ConfigNodeUtil.ParseValue <int>(configNode, "maxSimultaneous", ref maxSimultaneous, this, 0, x => Validation.GE(x, 0));
// Load rewards
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "rewardFunds", ref rewardFunds, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "rewardReputation", ref rewardReputation, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "rewardScience", ref rewardScience, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "failureFunds", ref failureFunds, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "failureReputation", ref failureReputation, this, 0.0f, x => Validation.GE(x, 0.0f));
valid &= ConfigNodeUtil.ParseValue <float>(configNode, "advanceFunds", ref advanceFunds, this, 0.0f, x => Validation.GE(x, 0.0f));
// Load other values
valid &= ConfigNodeUtil.ParseValue <double>(configNode, "weight", ref weight, this, 1.0, x => Validation.GT(x, 0.0f));
// Check for unexpected values - always do this last
valid &= ConfigNodeUtil.ValidateUnexpectedValues(configNode, this);
// Load parameters
paramFactories = new List <ParameterFactory>();
foreach (ConfigNode contractParameter in configNode.GetNodes("PARAMETER"))
{
ParameterFactory paramFactory = ParameterFactory.GenerateParameterFactory(contractParameter, this);
if (paramFactory != null)
{
paramFactories.Add(paramFactory);
}
else
{
valid = false;
}
}
// Check we have at least one valid parameter
if (paramFactories.Count() == 0)
{
LoggingUtil.LogError(this.GetType(), ErrorPrefix() + ": Need at least one parameter for a contract!");
valid = false;
}
// Load behaviours
behaviourFactories = new List <BehaviourFactory>();
foreach (ConfigNode requirementNode in configNode.GetNodes("BEHAVIOUR"))
{
BehaviourFactory behaviourFactory = BehaviourFactory.GenerateBehaviourFactory(requirementNode, this);
if (behaviourFactory != null)
{
behaviourFactories.Add(behaviourFactory);
}
else
{
valid = false;
}
}
// Load requirements
requirements = new List <ContractRequirement>();
foreach (ConfigNode requirementNode in configNode.GetNodes("REQUIREMENT"))
{
ContractRequirement requirement = ContractRequirement.GenerateRequirement(requirementNode, this);
if (requirement != null)
{
requirements.Add(requirement);
}
else
{
valid = false;
}
}
return(valid);
}
/// <summary>
/// Tests whether a contract can be offered.
/// </summary>
/// <param name="contract">The contract</param>
/// <returns>Whether the contract can be offered.</returns>
public bool MeetRequirements(ConfiguredContract contract)
{
// Hash check
if (contract.ContractState == Contract.State.Offered && contract.hash != hash)
{
LoggingUtil.LogDebug(this, "Cancelling offered contract of type " + name + ", contract definition changed.");
return(false);
}
// Check prestige
if (prestige.Count > 0 && !prestige.Contains(contract.Prestige))
{
LoggingUtil.LogVerbose(this, "Didn't generate contract type " + name + ", wrong prestige level.");
return(false);
}
// Checks for maxSimultaneous/maxCompletions
if (maxSimultaneous != 0 || maxCompletions != 0)
{
// Get the count of active contracts - excluding ours
int activeContracts = ContractSystem.Instance.GetCurrentContracts <ConfiguredContract>().
Count(c => c.contractType != null && c.contractType.name == name);
if (contract.ContractState == Contract.State.Offered || contract.ContractState == Contract.State.Active)
{
activeContracts--;
}
// Check if we're breaching the active limit
if (maxSimultaneous != 0 && activeContracts >= maxSimultaneous)
{
LoggingUtil.LogVerbose(this, "Didn't generate contract type " + name + ", too many active contracts.");
return(false);
}
// Check if we're breaching the completed limit
if (maxCompletions != 0)
{
int finishedContracts = ContractSystem.Instance.GetCompletedContracts <ConfiguredContract>().
Count(c => c.contractType != null && c.contractType.name == name);
if (finishedContracts + activeContracts >= maxCompletions)
{
LoggingUtil.LogVerbose(this, "Didn't generate contract type " + name + ", too many completed/active/offered contracts.");
return(false);
}
}
}
// Check the group values
if (group != null)
{
// Check the group active limit
int activeContracts = ContractSystem.Instance.GetCurrentContracts <ConfiguredContract>().Count(c => c.contractType != null && c.contractType.group == group);
if (contract.ContractState == Contract.State.Offered || contract.ContractState == Contract.State.Active)
{
activeContracts--;
}
if (group.maxSimultaneous != 0 && activeContracts >= group.maxSimultaneous)
{
LoggingUtil.LogVerbose(this, "Didn't generate contract type " + name + ", too many active contracts in group.");
return(false);
}
// Check the group completed limit
if (group.maxCompletions != 0)
{
int finishedContracts = ContractSystem.Instance.GetCompletedContracts <ConfiguredContract>().Count(c => c.contractType != null && c.contractType.group == group);
if (finishedContracts + activeContracts >= maxCompletions)
{
LoggingUtil.LogVerbose(this, "Didn't generate contract type " + name + ", too many completed contracts in group.");
return(false);
}
}
}
// Check special values are not null
if (contract.ContractState != Contract.State.Active)
{
foreach (KeyValuePair <string, bool> pair in dataValues)
{
// Only check if it is a required value
if (pair.Value)
{
string name = pair.Key;
object o = dataNode[name];
if (o == null)
{
LoggingUtil.LogVerbose(this, "Didn't generate contract type " + this.name + ", '" + name + "' was null.");
return(false);
}
else if (o == typeof(List <>))
{
PropertyInfo prop = o.GetType().GetProperty("Count");
int count = (int)prop.GetValue(o, null);
if (count == 0)
{
LoggingUtil.LogVerbose(this, "Didn't generate contract type " + this.name + ", '" + name + "' had zero count.");
return(false);
}
}
else if (o == typeof(Vessel))
{
Vessel v = (Vessel)o;
if (v.state == Vessel.State.DEAD)
{
LoggingUtil.LogVerbose(this, "Didn't generate contract type " + this.name + ", vessel '" + v.vesselName + "' is dead.");
return(false);
}
}
}
}
}
// Check the captured requirements
return(ContractRequirement.RequirementsMet(contract, this, requirements));
}
/// <summary>
/// Generates a ContractRequirement from a configuration node.
/// </summary>
/// <param name="configNode">ConfigNode to use in the generation.</param>
/// <param name="contractType">ContractType that this requirement falls under</param>
/// <param name="requirement">The ContractRequirement object.</param>
/// <returns>Whether the load was successful</returns>
public static bool GenerateRequirement(ConfigNode configNode, ContractType contractType, out ContractRequirement requirement,
IContractConfiguratorFactory parent = null)
{
// Logging on
LoggingUtil.CaptureLog = true;
bool valid = true;
// Get the type
string type = configNode.GetValue("type");
string name = configNode.HasValue("name") ? configNode.GetValue("name") : type;
if (string.IsNullOrEmpty(type))
{
LoggingUtil.LogError(typeof(ParameterFactory), "CONTRACT_TYPE '" + contractType.name + "'," +
"REQUIREMENT '" + configNode.GetValue("name") + "' does not specify the mandatory 'type' attribute.");
requirement = new InvalidContractRequirement();
valid = false;
}
else if (!requirementTypes.ContainsKey(type))
{
LoggingUtil.LogError(typeof(ParameterFactory), "CONTRACT_TYPE '" + contractType.name + "'," +
"REQUIREMENT '" + configNode.GetValue("name") + "' of type '" + configNode.GetValue("type") + "': " +
"Unknown requirement '" + type + "'.");
requirement = new InvalidContractRequirement();
valid = false;
}
else
{
// Create an instance of the ContractRequirement
requirement = (ContractRequirement)Activator.CreateInstance(requirementTypes[type]);
}
// Set attributes
requirement.contractType = contractType;
requirement.dataNode = new DataNode(name, parent != null ? parent.dataNode : contractType.dataNode, requirement);
// Load config
valid &= requirement.LoadFromConfig(configNode);
// Override the needsTitle if we have a parent node with hideChildren
ContractRequirement parentRequirement = parent as ContractRequirement;
if (parentRequirement != null)
{
if (parentRequirement.hideChildren)
{
requirement.hideChildren = true;
requirement.needsTitle = false;
}
}
// Check for unexpected values - always do this last
if (requirement.GetType() != typeof(InvalidContractRequirement))
{
valid &= ConfigNodeUtil.ValidateUnexpectedValues(configNode, requirement);
}
// Load child nodes
foreach (ConfigNode childNode in ConfigNodeUtil.GetChildNodes(configNode, "REQUIREMENT"))
{
ContractRequirement child = null;
valid &= ContractRequirement.GenerateRequirement(childNode, contractType, out child, requirement);
if (child != null)
{
requirement.childNodes.Add(child);
if (child.hasWarnings)
{
requirement.hasWarnings = true;
}
}
}
// Error for missing title
if (requirement.needsTitle && string.IsNullOrEmpty(requirement.title))
{
valid = contractType.minVersion < ContractConfigurator.ENHANCED_UI_VERSION;
LoggingUtil.Log(contractType.minVersion >= ContractConfigurator.ENHANCED_UI_VERSION ? LoggingUtil.LogLevel.ERROR : LoggingUtil.LogLevel.WARNING,
requirement, requirement.ErrorPrefix(configNode) + ": missing required attribute 'title'.");
}
requirement.enabled = valid;
requirement.log = LoggingUtil.capturedLog;
LoggingUtil.CaptureLog = false;
return valid;
}
/// <summary>
/// Generates a ContractRequirement from a configuration node.
/// </summary>
/// <param name="configNode">ConfigNode to use in the generation.</param>
/// <param name="contractType">ContractType that this requirement falls under</param>
/// <param name="requirement">The ContractRequirement object.</param>
/// <returns>Whether the load was successful</returns>
public static bool GenerateRequirement(ConfigNode configNode, ContractType contractType, out ContractRequirement requirement,
IContractConfiguratorFactory parent = null)
{
// Logging on
LoggingUtil.CaptureLog = true;
bool valid = true;
// Get the type
string type = configNode.GetValue("type");
string name = configNode.HasValue("name") ? configNode.GetValue("name") : type;
if (string.IsNullOrEmpty(type))
{
LoggingUtil.LogError(typeof(ParameterFactory), "CONTRACT_TYPE '{0}', REQUIREMENT '{1}' does not specify the mandatory 'type' attribute.",
contractType.name, configNode.GetValue("name"));
requirement = new InvalidContractRequirement();
valid = false;
}
else if (!requirementTypes.ContainsKey(type))
{
LoggingUtil.LogError(typeof(ParameterFactory), "CONTRACT_TYPE '{0}', REQUIREMENT '{1}' of type '{2}': Unknown requirement '{3}'.",
contractType.name, configNode.GetValue("name"), configNode.GetValue("type"), type);
requirement = new InvalidContractRequirement();
valid = false;
}
else
{
// Create an instance of the ContractRequirement
requirement = (ContractRequirement)Activator.CreateInstance(requirementTypes[type]);
}
// Set attributes
requirement.contractType = contractType;
requirement.dataNode = new DataNode(name, parent != null ? parent.dataNode : contractType.dataNode, requirement);
// Load config
valid &= requirement.LoadFromConfig(configNode);
// Override the needsTitle if we have a parent node with hideChildren
ContractRequirement parentRequirement = parent as ContractRequirement;
if (parentRequirement != null)
{
if (parentRequirement.hideChildren)
{
requirement.hideChildren = true;
requirement.needsTitle = false;
}
}
// Check for unexpected values - always do this last
if (requirement.GetType() != typeof(InvalidContractRequirement))
{
valid &= ConfigNodeUtil.ValidateUnexpectedValues(configNode, requirement);
}
// Load child nodes
foreach (ConfigNode childNode in ConfigNodeUtil.GetChildNodes(configNode, "REQUIREMENT"))
{
ContractRequirement child = null;
valid &= ContractRequirement.GenerateRequirement(childNode, contractType, out child, requirement);
if (child != null)
{
requirement.childNodes.Add(child);
if (child.hasWarnings)
{
requirement.hasWarnings = true;
}
}
}
// Error for missing title
if (requirement.needsTitle && string.IsNullOrEmpty(requirement.title))
{
valid = contractType.minVersion < ContractConfigurator.ENHANCED_UI_VERSION;
LoggingUtil.Log(contractType.minVersion >= ContractConfigurator.ENHANCED_UI_VERSION ? LoggingUtil.LogLevel.ERROR : LoggingUtil.LogLevel.WARNING,
requirement, "{0}: missing required attribute 'title'.", requirement.ErrorPrefix(configNode));
}
requirement.enabled = valid;
requirement.log = LoggingUtil.capturedLog;
LoggingUtil.CaptureLog = false;
return(valid);
}
/// <summary>
/// Generates a new ParameterFactory from the given ConfigNode.
/// </summary>
/// <param name="parameterConfig">ConfigNode to use in the generation.</param>
/// <param name="contractType">ContractType that this parameter factory falls under</param>
/// <param name="paramFactory">The ParameterFactory object.</param>
/// <param name="parent">ParameterFactory to use as the parent</param>
/// <returns>Whether the load was successful</returns>
public static bool GenerateParameterFactory(ConfigNode parameterConfig, ContractType contractType, out ParameterFactory paramFactory, ParameterFactory parent = null)
{
// Logging on
LoggingUtil.CaptureLog = true;
bool valid = true;
// Get the type
string type = parameterConfig.GetValue("type");
string name = parameterConfig.HasValue("name") ? parameterConfig.GetValue("name") : type;
if (string.IsNullOrEmpty(type))
{
LoggingUtil.LogError(typeof(ParameterFactory), "CONTRACT_TYPE '" + contractType.name + "'," +
"PARAMETER '" + parameterConfig.GetValue("name") + "' does not specify the mandatory 'type' attribute.");
paramFactory = new InvalidParameterFactory();
valid = false;
}
else if (!factories.ContainsKey(type))
{
LoggingUtil.LogError(typeof(ParameterFactory), "CONTRACT_TYPE '" + contractType.name + "'," +
"PARAMETER '" + parameterConfig.GetValue("name") + "' of type '" + parameterConfig.GetValue("type") + "': " +
"Unknown parameter '" + type + "'.");
paramFactory = new InvalidParameterFactory();
valid = false;
}
else
{
// Create an instance of the factory
paramFactory = (ParameterFactory)Activator.CreateInstance(factories[type]);
}
// Set attributes
paramFactory.parent = parent;
paramFactory.contractType = contractType;
paramFactory.dataNode = new DataNode(name, parent != null ? parent.dataNode : contractType.dataNode, paramFactory);
// Load child requirements
foreach (ConfigNode childNode in ConfigNodeUtil.GetChildNodes(parameterConfig, "REQUIREMENT"))
{
ContractRequirement req = null;
valid &= ContractRequirement.GenerateRequirement(childNode, contractType, out req, paramFactory);
if (req != null)
{
paramFactory.requirements.Add(req);
if (req.hasWarnings)
{
paramFactory.hasWarnings = true;
}
}
}
// Load config
if (!paramFactory.Load(parameterConfig))
{
// If there was a load failure, check if there are requirements
if (paramFactory.requirements.Count > 0)
{
LoggingUtil.LogWarning(paramFactory, "Ignoring failed parameter with child requirements.");
}
else
{
valid = false;
}
}
// Late initialize for iterator keys
valid &= DataNode.InitializeIteratorKey(parameterConfig, paramFactory);
// Check for unexpected values - always do this last
if (paramFactory.GetType() != typeof(InvalidParameterFactory))
{
valid &= ConfigNodeUtil.ValidateUnexpectedValues(parameterConfig, paramFactory);
}
paramFactory.log = LoggingUtil.capturedLog;
LoggingUtil.CaptureLog = false;
// Load child nodes
foreach (ConfigNode childNode in ConfigNodeUtil.GetChildNodes(parameterConfig, "PARAMETER"))
{
ParameterFactory child = null;
valid &= ParameterFactory.GenerateParameterFactory(childNode, contractType, out child, paramFactory);
if (child != null)
{
paramFactory.childNodes.Add(child);
if (child.hasWarnings)
{
paramFactory.hasWarnings = true;
}
}
}
paramFactory.enabled = valid;
return(valid);
}
public bool Initialize(ContractType contractType)
{
LoggingUtil.LogLevel origLogLevel = LoggingUtil.logLevel;
try
{
this.contractType = contractType;
if (contractType.trace)
{
LoggingUtil.logLevel = LoggingUtil.LogLevel.VERBOSE;
}
LoggingUtil.LogDebug(this, "Initializing contract: {0}", contractType);
// Set stuff from contract type
subType = contractType.name;
hash = contractType.hash;
AutoAccept = contractType.autoAccept;
// Set the contract expiry
if (contractType.maxExpiry == 0.0f)
{
LoggingUtil.LogDebug(this, "{0}: Setting expirty to none", contractType.name);
SetExpiry();
expiryType = DeadlineType.None;
}
else
{
SetExpiry(contractType.minExpiry, contractType.maxExpiry);
// Force set the expiry, in stock this is normally done on Contract.Offer()
dateExpire = GameTime + TimeExpiry;
}
// Set the contract deadline
if (contractType.deadline == 0.0f)
{
deadlineType = Contract.DeadlineType.None;
}
else
{
SetDeadlineDays(contractType.deadline, null);
}
// Set rewards
SetScience(contractType.rewardScience, contractType.targetBody);
SetReputation(contractType.rewardReputation, contractType.failureReputation, contractType.targetBody);
SetFunds(contractType.advanceFunds, contractType.rewardFunds, contractType.advanceFunds + contractType.failureFunds, contractType.targetBody);
// Copy text from contract type
title = contractType.title;
synopsis = contractType.synopsis;
completedMessage = contractType.completedMessage;
notes = contractType.notes;
// Set the agent
if (contractType.agent != null)
{
agent = contractType.agent;
}
else
{
agent = AgentList.Instance.GetSuitableAgentForContract(this);
}
// Workaround for agencies defined without a title
if (agent.Title == null)
{
agentField.SetValue(agent, agent.Name);
}
// Set description
if (string.IsNullOrEmpty(contractType.description) && agent != null)
{
// Generate the contract description
description = TextGen.GenerateBackStories("ConfiguredContract", agent.Name, contractType.topic, contractType.subject, random.Next(), true, true, true);
}
else
{
description = contractType.description;
}
// Generate behaviours
behaviours = new List <ContractBehaviour>();
if (!contractType.GenerateBehaviours(this))
{
return(false);
}
// Generate parameters
bool paramsGenerated = contractType.GenerateParameters(this);
bodiesLoaded = false;
contractType.contractBodies = ContractBodies;
if (!paramsGenerated)
{
return(false);
}
// Do a very late research bodies check
try
{
contractType.ResearchBodiesCheck(this);
}
catch (ContractRequirementException)
{
return(false);
}
// Copy in the requirement nodes
requirements = new List <ContractRequirement>();
foreach (ContractRequirement requirement in contractType.Requirements)
{
ConfigNode serializedRequirement = new ConfigNode();
requirement.Save(serializedRequirement);
ContractRequirement copy = ContractRequirement.LoadRequirement(serializedRequirement);
requirements.Add(copy);
}
LoggingUtil.LogDebug(this, "Initialized contract: {0}", contractType);
return(true);
}
catch (Exception e)
{
LoggingUtil.LogError(this, "Error initializing contract {0}", contractType);
LoggingUtil.LogException(e);
ExceptionLogWindow.DisplayFatalException(ExceptionLogWindow.ExceptionSituation.CONTRACT_GENERATION, e,
contractType == null ? "unknown" : contractType.FullName);
return(false);
}
finally
{
LoggingUtil.logLevel = origLogLevel;
}
}