protected void OnParameterChange(Contract c, ContractParameter p) { if (c == Root) { CheckVessel(FlightGlobals.ActiveVessel); } }
public TitleTracker(ContractParameter parameter) { this.parameter = parameter; GameEvents.Contract.onParameterChange.Add(new EventData<Contract, ContractParameter>.OnEvent(OnParameterChange)); GameEvents.onVesselRename.Add(new EventData<GameEvents.HostedFromToAction<Vessel, string>>.OnEvent(OnVesselRename)); }
/// <summary> /// Call this any time the title text has changed - this will make an attempt to update /// the contract window title. We do this because otherwise the window will only ever read /// the title once. /// </summary> /// <param name="newTitle">New title to display</param> public void UpdateContractWindow(ContractParameter param, string newTitle) { // Try to find the cascading list in the contracts window. Note that we may pick up // the ones from the Engineer's report in the VAB/SPH instead - but we don't care about // title updates in those scenes anyway. if (cascadingList == null || !cascadingList.gameObject.activeSelf) { cascadingList = UnityEngine.Object.FindObjectOfType<GenericCascadingList>(); } // Every time the clock ticks over, make an attempt to update the contract window // title. We do this because otherwise the window will only ever read the title once, // so this is the only way to get our fancy timer to work. // Go through all the list items in the contracts window if (cascadingList != null) { UIScrollList list = cascadingList.ruiList.cascadingList; if (list != null) { for (int i = 0; i < list.Count; i++) { // Try to find a rich text control that matches the expected text UIListItemContainer listObject = (UIListItemContainer)list.GetItem(i); SpriteTextRich richText = listObject.GetComponentInChildren<SpriteTextRich>(); if (richText != null) { // Check for any string in titleTracker string found = null; foreach (string title in titles) { if (richText.Text.EndsWith(title)) { found = title; break; } } // Clear the titleTracker, and replace the text if (found != null) { titles.Clear(); richText.Text = richText.Text.Replace(found, newTitle); titles.Add(newTitle); } } } // Reposition items to account for items where the height increased or decreased list.RepositionItems(); } } // Contracts Window + update ContractsWindow.SetParameterTitle(param, newTitle); }
protected override void OnParameterStateChange(ContractParameter param) { ConditionDetail.Condition cond = param.State == ParameterState.Complete ? ConditionDetail.Condition.PARAMETER_COMPLETED : ConditionDetail.Condition.PARAMETER_FAILED; if (param.State == ParameterState.Incomplete) { return; } UnlockABase(cond, param.ID, param.State == ParameterState.Complete ? basename : basename); }
/// <summary> /// Set the parameter notes. /// </summary> /// <param name="param">ContractParameter object</param> /// <param name="notes">New notes</param> public static void SetParameterNotes(ContractParameter param, string notes) { if (!VerifyVersion()) { return; } Type contractUtils = ContractsWindowAssembly.GetType("ContractsWindow.contractUtils"); // Get and invoke the method MethodInfo method = contractUtils.GetMethod("setParameterNotes"); method.Invoke(null, new object[] { param.Root, param, notes }); }
protected override void OnParameterStateChange(ContractParameter param) { ConditionDetail.Condition cond = param.State == ParameterState.Complete ? ConditionDetail.Condition.PARAMETER_COMPLETED : ConditionDetail.Condition.PARAMETER_FAILED; if (param.State == ParameterState.Incomplete) { return; } DisplayMessages(cond, param.ID,param.State == ParameterState.Complete ? MessageSystemButton.MessageButtonColor.GREEN : MessageSystemButton.MessageButtonColor.RED); }
private void onParamChange(Contract c, ContractParameter p) { contractContainer cc = contractParser.getActiveContract(c.ContractGuid); if (cc == null) return; if (c.AllParameters.Count() > cc.ParameterCount) { cc.updateFullParamInfo(); contractParser.onParameterAdded.Fire(c, p); } }
public bool CanRefactor(ContractParameter parameter) { if (IsBadDefaultValue(parameter.DefaultValue)) { return(false); } if (parameter.Type.SpecialType.In(_numberTypes)) { return(true); } return(false); }
protected override void OnParameterStateChange(ContractParameter contractParameter) { if (System.Object.ReferenceEquals(contractParameter.Parent, this)) { if (AllChildParametersComplete()) { SetState(ParameterState.Complete); } else if (AnyChildParametersFailed()) { SetState(ParameterState.Failed); } } }
/// <summary> /// Process "invoke" command /// </summary> /// <param name="scriptHash">Script hash</param> /// <param name="operation">Operation</param> /// <param name="result">Result</param> /// <param name="verificable">Transaction</param> /// <param name="contractParameters">Contract parameters</param> /// <returns>Return true if it was successful</returns> private bool OnInvokeWithResult(UInt160 scriptHash, string operation, out StackItem result, IVerifiable verificable = null, JArray contractParameters = null, bool showStack = true) { List <ContractParameter> parameters = new List <ContractParameter>(); if (contractParameters != null) { foreach (var contractParameter in contractParameters) { parameters.Add(ContractParameter.FromJson(contractParameter)); } } var snapshot = Blockchain.Singleton.GetSnapshot(); ContractState contract = NativeContract.ContractManagement.GetContract(snapshot, scriptHash); if (contract == null) { Console.WriteLine("Contract does not exist."); result = StackItem.Null; return(false); } else { if (contract.Manifest.Abi.GetMethod(operation) == null) { Console.WriteLine("This method does not not exist in this contract."); result = StackItem.Null; return(false); } } byte[] script; using (ScriptBuilder scriptBuilder = new ScriptBuilder()) { scriptBuilder.EmitDynamicCall(scriptHash, operation, parameters.ToArray()); script = scriptBuilder.ToArray(); Console.WriteLine($"Invoking script with: '{script.ToBase64String()}'"); } if (verificable is Transaction tx) { tx.Script = script; } using ApplicationEngine engine = ApplicationEngine.Run(script, container: verificable); PrintExecutionOutput(engine, showStack); result = engine.State == VMState.FAULT ? null : engine.ResultStack.Peek(); return(engine.State != VMState.FAULT); }
public static ScriptBuilder EmitPush(this ScriptBuilder sb, ContractParameter parameter) { switch (parameter.Type) { case ContractParameterType.Signature: case ContractParameterType.ByteArray: sb.EmitPush((byte[])parameter.Value); break; case ContractParameterType.Boolean: sb.EmitPush((bool)parameter.Value); break; case ContractParameterType.Integer: sb.EmitPush((BigInteger)parameter.Value); break; case ContractParameterType.Hash160: sb.EmitPush((UInt160)parameter.Value); break; case ContractParameterType.Hash256: sb.EmitPush((UInt256)parameter.Value); break; case ContractParameterType.PublicKey: sb.EmitPush((ECPoint)parameter.Value); break; case ContractParameterType.String: sb.EmitPush((string)parameter.Value); break; case ContractParameterType.Array: { IList <ContractParameter> parameters = (IList <ContractParameter>)parameter.Value; for (int i = parameters.Count - 1; i >= 0; i--) { sb.EmitPush(parameters[i]); } sb.EmitPush(parameters.Count); sb.Emit(OpCode.PACK); } break; default: throw new ArgumentException(); } return(sb); }
public new bool AnyChildParametersFailed() { for (int i = ParameterCount; i-- > 0;) { ContractParameter param = GetParameter(i); ContractConfiguratorParameter ccParam = param as ContractConfiguratorParameter; if (param.State == ParameterState.Failed && (ccParam == null || !ccParam.fakeFailures)) { return(true); } } return(false); }
/// <summary> /// Process "invoke" command /// </summary> /// <param name="scriptHash">Script hash</param> /// <param name="operation">Operation</param> /// <param name="result">Result</param> /// <param name="verificable">Transaction</param> /// <param name="contractParameters">Contract parameters</param> /// <param name="showStack">Show result stack if it is true</param> /// <param name="gas">Max fee for running the script</param> /// <returns>Return true if it was successful</returns> private bool OnInvokeWithResult(UInt160 scriptHash, string operation, out StackItem result, IVerifiable verificable = null, JArray contractParameters = null, bool showStack = true, long gas = TestModeGas) { List <ContractParameter> parameters = new List <ContractParameter>(); if (contractParameters != null) { foreach (var contractParameter in contractParameters) { parameters.Add(ContractParameter.FromJson(contractParameter)); } } ContractState contract = NativeContract.ContractManagement.GetContract(NeoSystem.StoreView, scriptHash); if (contract == null) { ConsoleHelper.Error("Contract does not exist."); result = StackItem.Null; return(false); } else { if (contract.Manifest.Abi.GetMethod(operation, parameters.Count) == null) { ConsoleHelper.Error("This method does not not exist in this contract."); result = StackItem.Null; return(false); } } byte[] script; using (ScriptBuilder scriptBuilder = new ScriptBuilder()) { scriptBuilder.EmitDynamicCall(scriptHash, operation, parameters.ToArray()); script = scriptBuilder.ToArray(); ConsoleHelper.Info("Invoking script with: ", $"'{script.ToBase64String()}'"); } if (verificable is Transaction tx) { tx.Script = script; } using ApplicationEngine engine = ApplicationEngine.Run(script, NeoSystem.StoreView, container: verificable, settings: NeoSystem.Settings, gas: gas); PrintExecutionOutput(engine, showStack); result = engine.State == VMState.FAULT ? null : engine.ResultStack.Peek(); return(engine.State != VMState.FAULT); }
internal static string paramTypeCheck(ContractParameter param) { if (param.GetType() == typeof(PartTest)) { return("partTest"); } if (contractAssembly.MCELoaded) { if (param.GetType() == contractAssembly._MCEType) { return("MCEScience"); } } if (contractAssembly.DMLoaded) { if (param.GetType() == contractAssembly._DMCType) { return("DMcollectScience"); } } if (contractAssembly.DMALoaded) { if (param.GetType() == contractAssembly._DMAType) { return("DManomalyScience"); } else { return(""); } } if (contractAssembly.DMAstLoaded) { if (param.GetType() == contractAssembly._DMAstType) { return("DMasteroidScience"); } else { return(""); } } return(""); }
protected static IEnumerable <T> AllDescendents <T>(ContractParameter p) where T : ContractParameter { for (int i = 0; i < p.ParameterCount; i++) { ContractParameter child = p.GetParameter(i); if (child is T) { yield return(child as T); } foreach (ContractParameter grandChild in AllDescendents <T>(child)) { yield return(grandChild as T); } } }
private ContractParameter[] ConvertToContractParameters(SimpleParameter[] parameters) { var neoParameter = new List <ContractParameter>(); foreach (var simpleParameter in parameters) { var p = new ContractParameter(simpleParameter.ParameterType) { Value = simpleParameter.Value }; neoParameter.Add(p); } return(neoParameter.ToArray()); }
protected override void OnParameterStateChange(ContractParameter p) { base.OnParameterStateChange(p); foreach (ContractParameter parameter in AllParameters) { if (parameter.State == ParameterState.Incomplete || parameter.State == ParameterState.Failed) { return; } } //All parameters are complete SetState(State.Completed); }
private void button2_Click(object sender, EventArgs e) { if (listView1.SelectedIndices.Count == 0) { return; } ContractParameter parameter = (ContractParameter)listView1.SelectedItems[0].Tag; using (ParametersEditor dialog = new ParametersEditor((IList <ContractParameter>)parameter.Value)) { dialog.ShowDialog(); listView1.SelectedItems[0].SubItems["value"].Text = parameter.ToString(); textBox1.Text = listView1.SelectedItems[0].SubItems["value"].Text; } }
protected void OnAnyContractParameterChange(Contract contract, ContractParameter contractParameter) { if (contract == Root) { LoggingUtil.LogVerbose(this, "OnAnyContractParameterChange"); if (this.GetChildren().Where(p => p.State == ParameterState.Complete).Any()) { SetState(ParameterState.Incomplete); } else { SetState(ParameterState.Complete); } } }
public static RpcInvokeResult FromJson(JObject json) { RpcInvokeResult invokeScriptResult = new RpcInvokeResult(); invokeScriptResult.Script = json["script"].AsString(); invokeScriptResult.State = json["state"].TryGetEnum <VM.VMState>(); invokeScriptResult.GasConsumed = json["gasconsumed"].AsString(); try { invokeScriptResult.Stack = ((JArray)json["stack"]).Select(p => ContractParameter.FromJson(p)).ToArray(); } catch { } invokeScriptResult.Tx = json["tx"]?.AsString(); return(invokeScriptResult); }
public void TestInvokeScriptNull() { var nullExecutionEngine = new NullExecutionEngine(); var stackItemStackMock = new NullStack(); nullExecutionEngine.PublicStackItemsStack = stackItemStackMock; var invocationProcess = new InvocationProcess(nullExecutionEngine); var intParameter = new IntegerContractParameter(1); var contractParameters = new ContractParameter[] { intParameter }; var invocationResult = invocationProcess.Invoke(null, contractParameters); Assert.IsNotNull(invocationResult); }
private void onParamChange(Contract c, ContractParameter p) { contractContainer cc = contractParser.getActiveContract(c.ContractGuid); if (cc == null) { return; } if (c.AllParameters.Count() > cc.ParameterCount) { cc.updateFullParamInfo(); contractParser.onParameterAdded.Fire(c, p); } }
/// <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); }
protected void OnParameterChange(Contract c, ContractParameter p) { if (c != contract) { return; } if (p.ID == unlockParameter && unlockCriteria == UnlockCriteria.PARAMETER_COMPLETION) { UnlockParts(); } if (p.ID == lockParameter && lockCriteria == LockCriteria.PARAMETER_COMPLETION) { LockParts(); } }
void StockOnParameterChange(Contract c, ContractParameter p) { // Workaround for stock bug #18267 if (p.State == ParameterState.Complete && p.FundsCompletion == 0 && p.ScienceCompletion == 0 && p.ReputationCompletion == 0) { Versioning v = Versioning.Instance as Versioning; if (v.versionMajor == 1 && v.versionMinor == 4 && v.revision == 2) { MessageSystem.Message message = MessageSystem.Instance.FindMessages(m => m.message.Contains(p.MessageComplete)).FirstOrDefault(); if (message != null) { MessageSystem.Instance.DiscardMessage(message.button); } } } }
protected override void OnParameterStateChange(ContractParameter param) { base.OnParameterStateChange(param); var matchingParameter = GetMatchingParameter(param); if (matchingParameter == null) { return; } if (matchingParameter.State == ParameterState.Complete) { DoShow(); } }
protected override void OnParameterStateChange(ContractParameter param) { ConditionDetail.Condition cond = param.State == ParameterState.Complete ? ConditionDetail.Condition.PARAMETER_COMPLETED : ConditionDetail.Condition.PARAMETER_FAILED; if (param.State == ParameterState.Incomplete) { return; } foreach (ConditionDetail cd in conditions.Where(cd => !cd.disabled && cd.condition == cond && cd.parameter == param.ID)) { DisplayMessage(title, message, param.State == ParameterState.Complete ? MessageSystemButton.MessageButtonColor.GREEN : MessageSystemButton.MessageButtonColor.RED); cd.disabled = true; } }
internal paramTypeContainer(Type PType) { paramType = PType; try { param = (ContractParameter)Activator.CreateInstance(PType); } catch (Exception e) { DMC_MBE.LogFormatted("This Parameter Type: {0} Does Not Have An Empty Constructor And Will Be Skipped: {1]", PType.Name, e); return; } name = PType.Name; name = Regex.Replace(name, "([a-z](?=[A-Z])|[A-Z](?=[A-Z][a-z]))", "$1 "); rewardFund = penaltyFund = rewardRep = penaltyRep = rewardScience = 1f; }
private void button1_Click(object sender, EventArgs e) { if (listView1.SelectedIndices.Count == 0) return; ContractParameter parameter = (ContractParameter)listView1.SelectedItems[0].Tag; try { parameter.SetValue(textBox2.Text); listView1.SelectedItems[0].SubItems["value"].Text = parameter.ToString(); textBox1.Text = listView1.SelectedItems[0].SubItems["value"].Text; textBox2.Clear(); } catch(Exception err) { MessageBox.Show(err.Message); } }
protected void OnParameterChange(Contract c, ContractParameter p) { if (c != Root) { return; } if (p.ID == startParameter && startCriteria == StartCriteria.PARAMETER_COMPLETION && startTime == 0.0) { SetStartTime(); } if (p.ID == endParameter && endCriteria == EndCriteria.PARAMETER_COMPLETION && endTime == 0.0) { SetEndTime(); } }
/// <summary> /// Checks the child conditions for each child parameter delegate in the given parent. /// </summary> /// <param name="param">The contract parameter that we are called from.</param> /// <param name="values">The values to enumerator over.</param> /// <param name="checkOnly">Only perform a check, don't change values.</param> /// <returns></returns> public static bool CheckChildConditions(ContractParameter param, T value, bool checkOnly = false) { bool conditionMet = true; int count = param.ParameterCount; for (int i = 0; i < param.ParameterCount; i++) { ParameterDelegate <T> delegateParam = param[i] as ParameterDelegate <T>; if (delegateParam != null) { conditionMet &= delegateParam.SetState(value); } } return(conditionMet); }
/// <summary> /// A method for returning a parameterContainer object. The contract and parameter in question must be loaded by /// Contracts Window + and may return null. All fields within the object are publicly accessible through properties. /// </summary> /// <param name="contract">Instance of the root contract (contractParameter.Root)</param> /// <param name="parameter">Instance of the contract parameter in question</param> /// <returns>parameterContainer object</returns> public static parameterContainer getParameterContainer(Contract contract, ContractParameter parameter) { try { contractContainer c = contractScenario.Instance.getContract(contract.ContractGuid); parameterContainer pC = null; if (c != null) pC = c.AllParamList.SingleOrDefault(a => a.CParam == parameter); return pC; } catch (Exception e) { Debug.LogWarning("[Contracts +] Something went wrong when attempting to get a Parameter Container object: " + e); return null; } }
/// <summary> /// Checks the child conditions for each child parameter delegate in the given parent. /// </summary> /// <param name="param">The contract parameter that we are called from.</param> /// <param name="values">The values to enumerator over.</param> /// <param name="checkOnly">Only perform a check, don't change values.</param> /// <returns></returns> protected static BitArray CheckChildConditions(ContractParameter param, IEnumerable <T> values, ref bool conditionMet, bool checkOnly = false) { int count = values.Count(); BitArray current = null; int paramCount = param.ParameterCount; for (int i = 0; i < paramCount; i++) { ParameterDelegate <T> paramDelegate = param[i] as ParameterDelegate <T>; if (paramDelegate != null) { LoggingUtil.LogVerbose(paramDelegate, "Checking condition for '{0}', conditionMet = {1}", paramDelegate.title, conditionMet); paramDelegate.InitializeBitArrays(values, current); paramDelegate.SetState(values, ref conditionMet, checkOnly); LoggingUtil.LogVerbose(paramDelegate, " after, conditionMet = {0}", conditionMet); if (paramDelegate.matchType == ParameterDelegateMatchType.FILTER) { current = paramDelegate.dest; } int newCount = GetCount(values, paramDelegate.dest); switch (paramDelegate.matchType) { case ParameterDelegateMatchType.FILTER: count = newCount; break; case ParameterDelegateMatchType.VALIDATE: conditionMet &= newCount > 0; break; case ParameterDelegateMatchType.VALIDATE_ALL: conditionMet &= count == newCount; break; case ParameterDelegateMatchType.NONE: conditionMet &= newCount == 0; break; } } } return(current); }
private void button3_Click(object sender, EventArgs e) { if (listBox1.SelectedIndex < 0) { return; } if (listBox2.SelectedIndex < 0) { return; } ContractParameter parameter = (ContractParameter)listBox2.SelectedItem; parameter.SetValue(textBox2.Text); listBox2.Items[listBox2.SelectedIndex] = parameter; textBox1.Text = textBox2.Text; button4.Visible = context.Completed; }
private void TestEmitPush2Array() { ScriptBuilder sb = new ScriptBuilder(); ContractParameter parameter = new ContractParameter(ContractParameterType.Array); IList <ContractParameter> values = new List <ContractParameter>(); values.Add(new ContractParameter(ContractParameterType.Integer)); values.Add(new ContractParameter(ContractParameterType.Integer)); parameter.Value = values; sb.EmitPush(parameter); byte[] tempArray = new byte[4]; tempArray[0] = 0x00; tempArray[1] = 0x00; tempArray[2] = 0x52; tempArray[3] = 0xC1; Assert.AreEqual(Encoding.Default.GetString(tempArray), Encoding.Default.GetString(sb.ToArray())); }
public ActionResult AjaxContractDelete(ContractParameter param) { var result = new JsonNetResult(); var r = new GeneralResponse(); try { r.Code = ContractProvider.Delete(param).ToString(Section.Get.Common.Culture); } catch (Exception ex) { Log.Error(ex.Message, ex); r.Code = "-11"; } result.Data = r; return(result); }
/// <summary> /// Gets the text of all the child delegates in one big string. Useful for printing out /// the full details for completed parameters. /// </summary> /// <param name="param">Th parent parameters.</param> /// <returns>The full delegate string</returns> public static string GetDelegateText(ContractParameter param) { string output = ""; foreach (ContractParameter child in param.AllParameters) { if (child is ParameterDelegate <T> && !((ParameterDelegate <T>)child).trivial) { if (!string.IsNullOrEmpty(output)) { output += "; "; } output += ((ParameterDelegate <T>)child).title; } } return(output); }
protected override void OnParameterStateChange(ContractParameter param) { if (param.State == ParameterState.Complete && parameter.Contains(param.ID)) { VesselParameterGroup vpg = param as VesselParameterGroup; SetCrew(vpg.TrackedVessel); // If the parameter is the last one to complete, then the events fire in the wrong // order. So check for that condition. if (contract.ContractState == Contract.State.Completed) { DoAwarding(); } // Sometimes we can also get multiple events for the same parameter (even without // disableOnStateChange set to false). So prevent duplicate experience rewards. parameter.Remove(param.ID); } }
public parameterContainer(contractContainer Root, ContractParameter cP, int Level) { root = Root; cParam = cP; try { title = cParam.Title; } catch (Exception e) { Debug.LogError("[Contract Parser] Contract Parameter Title not set, using type name...\n" + e); title = cParam.GetType().Name; } try { notes = cParam.Notes; } catch (Exception e) { Debug.LogError("[Contract Parser] Contract Parameter Notes not set, blank notes used...\n" + e); notes = ""; } level = Level; paramRewards(); paramPenalties(); waypoint = checkForWaypoint(); customNotes = setCustomNotes(); if (level < 4) { for (int i = 0; i < cParam.ParameterCount; i++) { ContractParameter param = cParam.GetParameter(i); addSubParam(param, level + 1); } } }
protected override void OnParameterStateChange(ContractParameter contractParameter) { if (System.Object.ReferenceEquals(contractParameter.Parent, this)) { SetupChildParameters(); bool foundNotComplete = false; for (int i = 0; i < ParameterCount; i++) { ContractParameter param = GetParameter(i); // Found an incomplete parameter if (param.State != ParameterState.Complete) { foundNotComplete = true; // If it's failed, just straight up fail the parameter if (param.State == ParameterState.Failed) { SetState(ParameterState.Failed); return; } } // We found a complete parameter after finding an incomplete one - failure condition else if (foundNotComplete && failWhenCompleteOutOfOrder) { SetState(ParameterState.Failed); return; } } // Everything we found was complete if (!foundNotComplete) { SetState(ParameterState.Complete); } } }
protected void OnParameterChange(Contract c, ContractParameter p) { visitWaypoint.OnParameterChange(c, p); }
public void OnParameterChange(Contract c, ContractParameter p) { if (c != Root) { return; } // Hide the waypoint if we are done with it if (hideOnCompletion && waypoint != null && waypoint.visible) { for (IContractParameterHost paramHost = this; paramHost != Root; paramHost = paramHost.Parent) { if (state == ParameterState.Complete) { ContractParameter param = paramHost as ContractParameter; if (param != null && !param.Enabled) { waypoint.visible = false; break; } } else { break; } } } }
protected void OnParameterStateChange(Contract contract, ContractParameter param) { if (contract == this) { OnParameterStateChange(param); } }
protected override void OnParameterStateChange(ContractParameter param) { base.OnParameterStateChange(param); foreach (ContractBehaviour behaviour in behaviours) { behaviour.ParameterStateChange(param); } // Check for completion - stock ignores the optional flag bool completed = true; foreach (ContractParameter child in this.GetChildren()) { if (child.State != ParameterState.Complete && !child.Optional) { completed = false; } } if (completed) { SetState(Contract.State.Completed); } }
internal static string DMagicAsteroidSciencePartName(ContractParameter cParam) { return _DMAst(cParam); }
protected override void OnParameterStateChange(ContractParameter param) { if (param.State == ParameterState.Complete && onParameterComplete.ContainsKey(param.ID)) { ExecuteExpressions(onParameterComplete[param.ID]); onParameterComplete[param.ID].Clear(); } }
internal static string FPPartName(ContractParameter cParam) { return _FP(cParam); }
protected override void OnParameterStateChange(ContractParameter param) { if (param.State == ParameterState.Complete) { foreach (WaypointData wpData in waypoints) { if (wpData.waypoint.visible && wpData.parameter == param.ID) { AddWayPoint(wpData.waypoint); } } } }
protected void OnParameterChange(Contract c, ContractParameter p) { if (c == Root && p.ID == parameter && timerType == TimerType.PARAMETER_COMPLETION && endTime == 0.0) { SetEndTime(); } }
protected override void OnParameterStateChange(ContractParameter param) { LoggingUtil.LogVerbose(this, "OnParameterStateChange"); // Just call OnOffered to add any missing waypoints OnOffered(); }
/// <summary> /// A method for manually resetting a locally cached contract parameter title. /// </summary> /// <param name="contract">Instance of the root contract (contractParameter.Root)</param> /// <param name="parameter">Instance of the contract parameter in question</param> /// <param name="name">The new contract parameter title</param> public static void setParameterTitle(Contract contract, ContractParameter parameter, string name) { try { contractContainer c = contractScenario.Instance.getContract(contract.ContractGuid); if (c != null) { parameterContainer pC = c.AllParamList.SingleOrDefault(a => a.CParam == parameter); if (pC != null) { pC.Title = name; } } } catch (Exception e) { Debug.LogWarning("[Contracts +] Something went wrong when attempting to assign a new Parameter Title: " + e); } }
private void addContractParam(ContractParameter param, int Level) { parameterContainer cc = new parameterContainer(this, param, Level); paramList.Add(cc); allParamList.Add(cc); }
internal static string paramTypeCheck(ContractParameter param) { if (param.GetType() == typeof(PartTest)) return "partTest"; if (contractAssembly.FPLoaded) { if (param.GetType() == contractAssembly._FPType) return "FinePrint"; } if (contractAssembly.MCELoaded) { if (param.GetType() == contractAssembly._MCEType) return "MCEScience"; } if (contractAssembly.DMLoaded) { if (param.GetType() == contractAssembly._DMCType) return "DMcollectScience"; } if (contractAssembly.DMALoaded) { if (param.GetType() == contractAssembly._DMAType) return "DManomalyScience"; else return ""; } if (contractAssembly.DMAstLoaded) { if (param.GetType() == contractAssembly._DMAstType) return "DMasteroidScience"; else return ""; } return ""; }
private void OnParameterChange(Contract contract, ContractParameter parameter) { if (contract != Root || parameter == this) { return; } TestConditions(); }
internal static string MCEPartName(ContractParameter cParam) { return _MCE(cParam); }
internal static string DMagicAnomalySciencePartName(ContractParameter cParam) { return _DMAnomaly(cParam); }
internal static string DMagicSciencePartName(ContractParameter cParam) { return _DMCollect(cParam); }