void Awake()
{
DontDestroyOnLoad(this);
Instance = this;
// Do a version check
Assembly dtvAssembly = Util.Version.VerifyAssemblyVersion("DraftTwitchViewers", "2.3.1", true);
if (dtvAssembly == null)
{
LoggingUtil.LogDebug(this, "Unable to find DraftTwitchViewers assembly.");
Destroy(this);
return;
}
LoggingUtil.LogDebug(this, "Found DraftTwitchViewers assembly.");
Type draftManager = dtvAssembly.GetTypes().Where(t => t.Name.Contains("ScenarioDraftManager")).FirstOrDefault();
if (draftManager == null)
{
LoggingUtil.LogError(this, "Couldn't get ScenarioDraftManager from DraftTwitchViewers!");
Destroy(this);
return;
}
draftMethod = draftManager.GetMethods(BindingFlags.Public | BindingFlags.Static).
Where(mi => mi.Name == "DraftKerbal").FirstOrDefault();
if (draftMethod == null)
{
LoggingUtil.LogError(this, "Couldn't get DraftKerbal method from DraftTwitchViewers!");
Destroy(this);
return;
}
saveMethod = draftManager.GetMethods(BindingFlags.Public | BindingFlags.Static).
Where(mi => mi.Name == "SaveSupressedDraft").FirstOrDefault();
if (saveMethod == null)
{
LoggingUtil.LogError(this, "Couldn't get SaveSupressedDraft method from DraftTwitchViewers!");
Destroy(this);
return;
}
GameEvents.Contract.onAccepted.Add(new EventData <Contract> .OnEvent(OnContractAccepted));
ContractPreLoader.OnInitializeValues.Add(new EventVoid.OnEvent(OnPreLoaderInitializeValues));
ContractPreLoader.OnInitializeFail.Add(new EventVoid.OnEvent(OnPreLoaderInitializeFail));
}
void Update()
{
// Load all the contract configurator configuration
if (HighLogic.LoadedScene == GameScenes.MAINMENU && !loaded)
{
LoggingUtil.LoadDebuggingConfig();
RegisterParameterFactories();
RegisterBehaviourFactories();
RegisterContractRequirements();
LoadContractConfig();
loaded = true;
}
// Try to disable the contract types
else if ((HighLogic.LoadedScene == GameScenes.SPACECENTER) && !contractTypesAdjusted)
{
if (AdjustContractTypes())
{
contractTypesAdjusted = true;
}
}
// Alt-F9 shows the contract configurator window
if (GameSettings.MODIFIER_KEY.GetKey() && Input.GetKeyDown(KeyCode.F10))
{
showGUI = !showGUI;
}
// Check if the ContractsApp has just become visible, and fire off an update event
if (!contractsAppVisible &&
ContractsApp.Instance != null &&
ContractsApp.Instance.appLauncherButton != null &&
ContractsApp.Instance.cascadingList.cascadingList != null &&
ContractsApp.Instance.cascadingList.cascadingList.gameObject.activeInHierarchy)
{
contractsAppVisible = true;
// Fire off an event for each contract
for (int i = 0; i < ContractSystem.Instance.Contracts.Count; i++)
{
Contract contract = ContractSystem.Instance.Contracts[i];
if (contract.ContractState == Contract.State.Active && contract.GetType() == typeof(ConfiguredContract))
{
GameEvents.Contract.onParameterChange.Fire(contract, contract.GetParameter(0));
}
}
}
}
public static string KerbalName(string defaultName)
{
LoggingUtil.LogVerbose(typeof(DraftTwitchViewers), "KerbalName()");
if (Instance != null && Instance.nameQueue.Any() && HighLogic.LoadedScene != GameScenes.MAINMENU)
{
string name = Instance.nameQueue.Dequeue();
Instance.recentNames.Enqueue(name);
LoggingUtil.LogVerbose(typeof(DraftTwitchViewers), " " + name);
return(name);
}
else
{
return(defaultName);
}
}
/// <summary>
/// Registers all the BehaviourFactory classes.
/// </summary>
void RegisterBehaviourFactories()
{
LoggingUtil.LogDebug(this.GetType(), "Start Registering BehaviourFactories");
// Register each type with the behaviour factory
foreach (Type subclass in GetAllTypes <BehaviourFactory>())
{
string name = subclass.Name;
if (name.EndsWith("Factory"))
{
name = name.Remove(name.Length - 7, 7);
}
BehaviourFactory.Register(subclass, name);
}
LoggingUtil.LogInfo(this.GetType(), "Finished Registering BehaviourFactories");
}
/*
* Adds a new BehaviourFactory to handle Behaviour nodes with the given type.
*/
public static void Register(Type factoryType, string typeName)
{
LoggingUtil.LogDebug(typeof(BehaviourFactory), "Registering behaviour factory class " +
factoryType.FullName + " for handling BEHAVIOUR nodes with type = " + typeName + ".");
if (factories.ContainsKey(typeName))
{
LoggingUtil.LogError(typeof(BehaviourFactory), "Cannot register " + factoryType.FullName + "[" + factoryType.Module +
"] to handle type " + typeName + ": already handled by " +
factories[typeName].FullName + "[" +
factories[typeName].Module + "]");
}
else
{
factories.Add(typeName, factoryType);
}
}
/// <summary>
/// Performs validation to check if the given config node has values that were not expected.
/// </summary>
/// <param name="configNode">The ConfigNode to check.</param>
/// <param name="obj">IContractConfiguratorFactory object for error reporting</param>
/// <returns>Always true, but logs a warning if unexpected keys were found</returns>
public static bool ValidateUnexpectedValues(ConfigNode configNode, IContractConfiguratorFactory obj)
{
bool valid = true;
if (!keysFound.ContainsKey(configNode))
{
obj.hasWarnings = true;
LoggingUtil.LogWarning(obj.GetType(), obj.ErrorPrefix() +
": did not attempt to load values for ConfigNode!");
return(false);
}
Dictionary <string, int> found = keysFound[configNode];
foreach (ConfigNode.Value pair in configNode.values)
{
if (!found.ContainsKey(pair.name))
{
obj.hasWarnings = true;
LoggingUtil.LogWarning(obj.GetType(), obj.ErrorPrefix() +
": unexpected attribute '" + pair.name + "' found, ignored.");
}
}
foreach (ConfigNode child in configNode.nodes)
{
// Exceptions
if (child.name == "PARAMETER" && (obj is ContractType || obj is ParameterFactory) ||
child.name == "REQUIREMENT" && (obj is ContractType || obj is ParameterFactory || obj is ContractRequirement) ||
child.name == "BEHAVIOUR" && (obj is ContractType) ||
child.name == "ORBIT" && (obj is Behaviour.OrbitGeneratorFactory || obj is Behaviour.SpawnVesselFactory || obj is Behaviour.SpawnKerbalFactory))
{
continue;
}
if (!found.ContainsKey(child.name))
{
obj.hasWarnings = true;
LoggingUtil.LogWarning(obj.GetType(), obj.ErrorPrefix() +
": unexpected child node '" + child.name + "' found, ignored.");
}
}
return(valid);
}
/*
* Adds a new ContractRequirement to handle REQUIREMENT nodes with the given type.
*/
public static void Register(Type crType, string typeName)
{
LoggingUtil.LogDebug(typeof(ContractRequirement), "Registering ContractRequirement class " +
crType.FullName + " for handling REQUIREMENT nodes with type = " + typeName + ".");
if (requirementTypes.ContainsKey(typeName))
{
LoggingUtil.LogError(typeof(ContractRequirement), "Cannot register " + crType.FullName + "[" + crType.Module +
"] to handle type " + typeName + ": already handled by " +
requirementTypes[typeName].FullName + "[" +
requirementTypes[typeName].Module + "]");
}
else
{
requirementTypes.Add(typeName, crType);
}
}
/// <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");
}
public override bool Load(ConfigNode configNode)
{
// Load base class
bool valid = base.Load(configNode);
if (configNode.HasValue("vesselKey"))
{
LoggingUtil.LogWarning(this, "The 'vesselKey' attribute is obsolete as of Contract Configurator 0.7.5. It will be removed in 1.0.0 in favour of the vessel attribute.");
valid &= ConfigNodeUtil.ParseValue <VesselIdentifier>(configNode, "vesselKey", x => vesselKey = x, this);
}
else
{
valid &= ConfigNodeUtil.ParseValue <VesselIdentifier>(configNode, "vessel", x => vesselKey = x, this);
}
return(valid);
}
public override bool Load(ConfigNode configNode)
{
// Load base class
bool valid = base.Load(configNode);
// Get type
string contractType = null;
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "contractType", x => contractType = x, this);
if (valid)
{
if (ContractType.GetContractType(contractType) != null)
{
ccType = contractType;
}
else
{
ccType = null;
// Search for the correct type
var classes =
from assembly in AppDomain.CurrentDomain.GetAssemblies()
from type in assembly.GetTypes()
where type.IsSubclassOf(typeof(Contract)) && type.Name.Equals(contractType)
select type;
if (classes.Count() < 1)
{
valid = false;
LoggingUtil.LogError(this.GetType(), "contractType '" + contractType +
"' must either be a Contract sub-class or ContractConfigurator contract type");
}
else
{
contractClass = classes.First();
}
}
}
valid &= ConfigNodeUtil.ParseValue <uint>(configNode, "minCount", x => minCount = x, this, 1);
valid &= ConfigNodeUtil.ParseValue <uint>(configNode, "maxCount", x => maxCount = x, this, UInt32.MaxValue);
valid &= ConfigNodeUtil.ParseValue <Duration>(configNode, "cooldownDuration", x => cooldownDuration = x, this, new Duration(0.0));
return(valid);
}
protected virtual void OnVesselDestroy(Vessel vessel)
{
LoggingUtil.LogVerbose(this, "OnVesselDestroy " + vessel.id);
if (HighLogic.LoadedScene != GameScenes.FLIGHT)
{
LoggingUtil.LogVerbose(this, " returning, not in flight scene");
return;
}
// Try to change any associations over if this is due to a docking event
foreach (string key in GetAssociatedKeys(vessel).ToList())
{
LoggingUtil.LogVerbose(this, " checking key " + key);
// Check if we need to switch over to the newly created vessel
VesselInfo vi = vessels[key];
Vessel newVessel = FlightGlobals.Vessels.Find(v => {
if (v != null && v != vessel)
{
LoggingUtil.LogVerbose(this, " loading protovessel for " + v.vesselName);
// If the vessel is loaded, refresh the protovessel. We do this to support
// grappling - when a new vessel is grappled the protovessel information
// doesn't get properly updated.
if (v.loaded)
{
v.protoVessel = new ProtoVessel(v);
}
return(v.GetHashes().Contains(vi.hash));
}
return(false);
});
if (newVessel != null)
{
vi.id = newVessel.id;
}
else
{
AssociateVessel(key, null);
}
}
}
/// <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)
{
throw new Exception(GetType().FullName + ".Generate() returned a null ContractParameter!");
}
// 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.hideChildren = hideChildren;
}
return(parameter);
}
protected override void OnLoad(ConfigNode node)
{
try
{
subType = node.GetValue("subtype");
contractType = string.IsNullOrEmpty(subType) ? null : 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);
foreach (ConfigNode child in node.GetNodes("BEHAVIOUR"))
{
ContractBehaviour behaviour = ContractBehaviour.LoadBehaviour(child, this);
behaviours.Add(behaviour);
}
// 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
{
SetState(State.Failed);
}
catch { }
return;
}
}
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 { }
}
}
public static void SetContractToDisabled(string contract, ContractGroup group)
{
Type contractType = contractTypes.Where(t => t.Name == contract).FirstOrDefault();
if (contractType == null)
{
LoggingUtil.LogWarning(typeof(ContractDisabler), "Couldn't find ContractType '" + contract + "' to disable.");
}
if (!contractDetails.ContainsKey(contractType))
{
contractDetails[contractType] = new ContractDetails(contractType);
}
ContractDetails details = contractDetails[contractType];
details.disablingGroups.AddUnique(group);
SetContractState(contractType, false);
}
public override void OnSave(ConfigNode node)
{
try
{
base.OnSave(node);
foreach (ScienceSubject s in trackedSubjects)
{
node.AddValue("subject", s.id);
}
}
catch (Exception e)
{
LoggingUtil.LogError(this, "Error saving ScienceReporter to persistance file!");
LoggingUtil.LogException(e);
ExceptionLogWindow.DisplayFatalException(ExceptionLogWindow.ExceptionSituation.SCENARIO_MODULE_SAVE, e, "ScienceReporter");
}
}
/// <summary>
/// Adds a new BehaviourFactory to handle Behaviour nodes with the given type.
/// </summary>
/// <param name="factoryType">Type of the factory</param>
/// <param name="typeName">Name to associate with the given type</param>
public static void Register(Type factoryType, string typeName)
{
LoggingUtil.LogDebug(typeof(BehaviourFactory), "Registering behaviour factory class {0} for handling BEHAVIOUR nodes with type = {1}.", factoryType.FullName, typeName);
if (factories.ContainsKey(typeName))
{
LoggingUtil.LogError(typeof(BehaviourFactory), "Cannot register {0}[{1}] to handle type {2}: already handled by {3}[{4}]",
factoryType.FullName, factoryType.Module, typeName, factories[typeName].FullName, factories[typeName].Module);
}
else
{
// Make sure we can instantiate it (this will also run any static initializers)
Activator.CreateInstance(factoryType);
// Add it to our list
factories.Add(typeName, factoryType);
}
}
public override void OnSave(ConfigNode node)
{
try
{
foreach (ConfiguredContract contract in contracts.Where(c => c.ContractState == Contract.State.Offered))
{
ConfigNode child = new ConfigNode("CONTRACT");
node.AddNode(child);
contract.Save(child);
}
}
catch (Exception e)
{
LoggingUtil.LogError(this, "Error saving ContractPreLoader to persistance file!");
LoggingUtil.LogException(e);
ExceptionLogWindow.DisplayFatalException(ExceptionLogWindow.ExceptionSituation.SCENARIO_MODULE_SAVE, e, "ContractPreLoader");
}
}
/// <summary>
/// Adds a new ContractRequirement to handle REQUIREMENT nodes with the given type.
/// </summary>
/// <param name="crType">ContractRequirement type</param>
/// <param name="typeName">Name to associate to the type</param>
public static void Register(Type crType, string typeName)
{
LoggingUtil.LogDebug(typeof(ContractRequirement), "Registering ContractRequirement class {0} for handling REQUIREMENT nodes with type = {1}.", crType.FullName, typeName);
if (requirementTypes.ContainsKey(typeName))
{
LoggingUtil.LogError(typeof(ContractRequirement), "Cannot register {0}[{1}] to handle type {2}: already handled by {3}[{4}]",
crType.FullName, crType.Module, typeName, requirementTypes[typeName].FullName, requirementTypes[typeName].Module);
}
else
{
// Make sure we can instantiate it (this will also run any static initializers)
Activator.CreateInstance(crType);
// Add it to our list
requirementTypes.Add(typeName, crType);
}
}
/*
* Attempts to parse a value from the config node.
*/
public static bool ParseValue <T>(ConfigNode configNode, string key, ref T value, IContractConfiguratorFactory obj)
{
try
{
value = ParseValue <T>(configNode, key);
return(value != null);
}
catch (Exception e)
{
LoggingUtil.LogError(obj, obj.ErrorPrefix(configNode) + ": Error parsing " + key + ": " + configNode.id + e.Message);
LoggingUtil.LogDebug(obj, e.StackTrace);
return(false);
}
finally
{
AddFoundKey(configNode, key);
}
}
public override bool MeetRequirements()
{
// No ContractType chosen
if (contractType == null)
{
return(SelectContractType());
}
else
{
// ContractType already chosen, check if still meets requirements.
bool meets = contractType.MeetRequirements(this);
if (ContractState == State.Active && !meets)
{
LoggingUtil.LogWarning(this, "Removed contract '" + title + "', as it no longer meets the requirements.");
}
return(meets);
}
}
/// <summary>
/// Creates a permanent link between the given vessel and key.
/// </summary>
/// <param name="key">The key to create an association with.</param>
/// <param name="vessel">The vessel that will be associated with the key</param>
public void AssociateVessel(string key, Vessel vessel)
{
// Already associated!
if (vessel != null && vessels.ContainsKey(key) && vessels[key].id == vessel.id)
{
return;
}
else if (vessel == null && !vessels.ContainsKey(key))
{
return;
}
if (vessel != null)
{
LoggingUtil.LogVerbose(this, "Associating vessel " + vessel.id + " with key '" + key + "'.");
}
else
{
LoggingUtil.LogVerbose(this, "Disassociating key '" + key + "'.");
}
// First remove whatever was there
if (vessels.ContainsKey(key))
{
Guid oldVesselId = vessels[key].id;
Vessel oldVessel = FlightGlobals.Vessels.Find(v => v != null && v.id == oldVesselId);
vessels.Remove(key);
if (oldVessel != null)
{
LoggingUtil.LogVerbose(this, "Firing OnVesselDisassociation.");
OnVesselDisassociation.Fire(new GameEvents.HostTargetAction <Vessel, string>(oldVessel, key));
}
}
// Add the new vessel
if (vessel != null)
{
vessels[key] = new VesselInfo(vessel);
LoggingUtil.LogVerbose(this, "Firing OnVesselAssociation.");
OnVesselAssociation.Fire(new GameEvents.HostTargetAction <Vessel, string>(vessel, key));
}
}
/// <summary>
/// Checks if all the given ContractRequirement meet the requirement.
/// </summary>
/// <param name="contract">Contract to check</param>
/// <param name="contractType">Contract type of the contract (in case the contract type has not yet been assigned).</param>
/// <param name="contractRequirements">The list of requirements to check</param>
/// <returns>Whether the requirement is met or not.</returns>
public static bool RequirementsMet(ConfiguredContract contract, ContractType contractType, IEnumerable <ContractRequirement> contractRequirements)
{
bool allReqMet = true;
try
{
LoggingUtil.LogVerbose(typeof(ContractRequirement), "Checking requirements for contract '{0}'", contractType.name);
foreach (ContractRequirement requirement in contractRequirements)
{
if (requirement.enabled)
{
if (requirement.checkOnActiveContract || contract == null || contract.ContractState != Contract.State.Active)
{
allReqMet = allReqMet && requirement.CheckRequirement(contract);
if (!allReqMet)
{
LoggingUtil.Log(contract != null && contract.ContractState == Contract.State.Active ? LoggingUtil.LogLevel.INFO :
contract != null && contract.ContractState == Contract.State.Offered ? LoggingUtil.LogLevel.DEBUG : LoggingUtil.LogLevel.VERBOSE,
requirement.GetType(), "Contract {0}: requirement {1} was not met.", contractType.name, requirement.name);
break;
}
}
}
}
// Force fail the contract if a requirement becomes unmet
if (contract != null && contract.ContractState == Contract.State.Active && !allReqMet)
{
// Fail the contract - unfortunately, the player won't know why. :(
contract.Fail();
// Force the stock contracts window to refresh
GameEvents.Contract.onContractsLoaded.Fire();
}
}
catch (Exception e)
{
LoggingUtil.LogException(new Exception("ContractConfigurator: Exception checking requirements!", e));
return(false);
}
return(allReqMet);
}
/*
* Loads a behaviour from a ConfigNode.
*/
public static ContractBehaviour LoadBehaviour(ConfigNode configNode, ConfiguredContract contract)
{
// Determine the type
string typeName = configNode.GetValue("type");
Type type = Type.GetType(typeName);
if (type == null)
{
LoggingUtil.LogError(typeof(ContractBehaviour), "No ContractBehaviour with type = '" + typeName + "'.");
return(null);
}
// Instantiate and load
ContractBehaviour behaviour = (ContractBehaviour)Activator.CreateInstance(type);
behaviour.contract = contract;
behaviour.Load(configNode);
return(behaviour);
}
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 static void OnSuccess(Dictionary <string, string> dict)
{
Instance.routinesRunning--;
if (!dict.ContainsKey("name"))
{
return;
}
string name = dict["name"];
LoggingUtil.LogVerbose(typeof(DraftTwitchViewers), "DraftTwitchViewers Success: " + name);
// Queue the name if it is new
if (Instance.IsUnique(name))
{
Instance.nameQueue.Enqueue(name);
Instance.names.Add(name);
}
}
/// <summary>
/// Reverses the localization of a string and gets the parameters out (as strings)
/// </summary>
/// <param name="input">Input string</param>
/// <param name="localizationTag">Localization tag to use to reverse localization.</param>
/// <returns></returns>
public static IList <string> UnLocalizeString(string input, string localizationTag)
{
LoggingUtil.LogVerbose(typeof(LocalizationUtil), "UnLocalizeString('{0}', '{1}')", input, localizationTag);
unlocalizedStringStorage.Clear();
int inputPos = 0;
int currentPos = 0;
int paramIndex = localizationTag.IndexOf("<<", currentPos);
int len = localizationTag.Length;
while (paramIndex >= 0 && paramIndex < len)
{
// Fast forward the input to the same location.
inputPos += paramIndex - currentPos;
//<<1>> <<2>>
// Get the location of the *next* parameter
currentPos = paramIndex + 5;
paramIndex = localizationTag.IndexOf("<<", currentPos);
if (paramIndex == -1)
{
paramIndex = len;
}
// Get the next literal part of the localization tag
string searchValue = localizationTag.Substring(currentPos, paramIndex - currentPos);
int index = (currentPos == paramIndex) ? input.Length : input.IndexOf(searchValue, inputPos);
if (index == -1)
{
LoggingUtil.LogError(typeof(LocalizationUtil), "Couldn't unlocalize string '{0}'", input);
return(unlocalizedStringStorage.AsReadOnly());
}
// Get the parameter and fast forward past it
string parameterValue = input.Substring(inputPos, index - inputPos);
inputPos = index;
LoggingUtil.LogVerbose(typeof(LocalizationUtil), " adding parameter '{0}'", parameterValue);
unlocalizedStringStorage.Add(parameterValue);
}
return(unlocalizedStringStorage.AsReadOnly());
}
protected virtual void OnVesselDestroy(Vessel vessel)
{
LoggingUtil.LogVerbose(this, "OnVesselDestroy " + vessel.id);
// Try to change any associations over if this is due to a docking event
foreach (string key in GetAssociatedKeys(vessel).ToList())
{
// Check if we need to switch over to the newly created vessel
VesselInfo vi = vessels[key];
Vessel newVessel = FlightGlobals.Vessels.Find(v => v != vessel && v.GetHashes().Contains(vi.hash));
if (newVessel != null)
{
vi.id = newVessel.id;
}
else
{
AssociateVessel(key, null);
}
}
}
public override bool LoadFromConfig(ConfigNode configNode)
{
// Before loading, verify the SCANsat version
if (!SCANsatUtil.VerifySCANsatVersion())
{
return(false);
}
// Load base class
bool valid = base.LoadFromConfig(configNode);
// Do not check the requirement on active contracts. Otherwise when they scan the
// contract is invalidated, which is usually not what's meant.
checkOnActiveContract = false;
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "scanType", x => scanType = x, this, "Anomaly", SCANsatUtil.ValidateSCANname);
valid &= ConfigNodeUtil.ParseValue <double>(configNode, "latitude", x => latitude = x, this, 0.0);
valid &= ConfigNodeUtil.ParseValue <double>(configNode, "longitude", x => longitude = x, this, 0.0);
valid &= ConfigNodeUtil.MutuallyExclusive(configNode, new string[] { "latitude", "longitude" }, new string[] { "pqsCity" }, this);
valid &= ValidateTargetBody(configNode);
string pqsName = null;
valid &= ConfigNodeUtil.ParseValue <string>(configNode, "pqsCity", x => pqsName = x, this, (string)null);
if (pqsName != null)
{
try
{
pqsCity = targetBody.GetComponentsInChildren <PQSCity>(true).Where(pqs => pqs.name == pqsName).First();
}
catch (Exception e)
{
LoggingUtil.LogError(this, "Couldn't load PQSCity with name '" + pqsCity + "'");
LoggingUtil.LogException(e);
valid = false;
}
}
return(valid);
}
/// <summary>
/// Adds a new ParameterFactory to handle PARAMETER nodes with the given type.
/// </summary>
/// <param name="factoryType">Type of factory to register.</param>
/// <param name="typeName">The name of the factory.</param>
public static void Register(Type factoryType, string typeName)
{
LoggingUtil.LogDebug(typeof(ParameterFactory), "Registering parameter factory class " +
factoryType.FullName + " for handling PARAMETER nodes with type = " + typeName + ".");
if (factories.ContainsKey(typeName))
{
LoggingUtil.LogError(typeof(ParameterFactory), "Cannot register " + factoryType.FullName + "[" + factoryType.Module +
"] to handle type " + typeName + ": already handled by " +
factories[typeName].FullName + "[" +
factories[typeName].Module + "]");
}
else
{
// Make sure we can instantiate it (this will also run any static initializers)
Activator.CreateInstance(factoryType);
// Add it to our list
factories.Add(typeName, factoryType);
}
}
void OnContractDecline(Contract c)
{
LoggingUtil.LogVerbose(this, "OnContractDecline");
// Reset generation failures for just this contract type
ConfiguredContract cc = c as ConfiguredContract;
if (cc != null)
{
if (cc.preLoaded)
{
contracts.Remove(cc);
}
if (cc.contractType != null)
{
lastGenerationFailure = -100.0;
cc.contractType.failedGenerationAttempts = 0;
cc.contractType.lastGenerationFailure = -100.0;
}
}
}