public void Start(ParameterDelegate method, object parameter) { SynchronizationContext context = SynchronizationContext.Current; // if there is no synchronization, don't launch a new thread if ( context != null ) { // new thread to execute the Load() method for the layer new Thread( ( object args ) => { method.DynamicInvoke( args ); //// fire the OnLoadComplete event on the original thread //context.Post( new SendOrPostCallback( ( obj ) => //{ // add callback method call here if needed in future //} ), null ); } ).Start( parameter ); } else { method.DynamicInvoke( parameter ); } }
protected override void OnParameterLoad(ConfigNode node) { monolithDiscovered = ConfigNodeUtil.ParseValue <bool>(node, "monolithDiscovered"); currentState = ConfigNodeUtil.ParseValue <MonolithState>(node, "currentState"); starJeb = ConfigNodeUtil.ParseValue <Vessel>(node, "starJeb", (Vessel)null); candidate = ConfigNodeUtil.ParseValue <Vessel>(node, "candidate", starJeb); starJebName = ConfigNodeUtil.ParseValue <string>(node, "starJebName", ""); candidateName = ConfigNodeUtil.ParseValue <string>(node, "candidateName", ""); if (node.HasValue("velocity.x")) { float x = ConfigNodeUtil.ParseValue <float>(node, "velocity.x"); float y = ConfigNodeUtil.ParseValue <float>(node, "velocity.y"); float z = ConfigNodeUtil.ParseValue <float>(node, "velocity.z"); velocity = new Vector3(x, y, z); } if (node.HasNode("PROGRESS_TREE_BACKUP")) { progressTreeBackup = node.GetNode("PROGRESS_TREE_BACKUP"); } stepTime = Time.fixedTime; ParameterDelegate <string> .OnDelegateContainerLoad(node); CreateDelegates(); }
protected override void OnParameterLoad(ConfigNode node) { try { field = ConfigNodeUtil.ParseValue <RadiationFieldType>(node, "field", RadiationFieldType.UNDEFINED); targetBody = ConfigNodeUtil.ParseValue <CelestialBody>(node, "targetBody", (CelestialBody)null); crossings_min = ConfigNodeUtil.ParseValue <int>(node, "crossings_min", 0); crossings_max = ConfigNodeUtil.ParseValue <int>(node, "crossings_max", 0); title = ConfigNodeUtil.ParseValue(node, "title", string.Empty); } finally { ParameterDelegate <Vessel> .OnDelegateContainerLoad(node); } }
protected override void OnParameterLoad(ConfigNode node) { base.OnParameterLoad(node); minRange = ConfigNodeUtil.ParseValue <double>(node, "minRange"); maxRange = ConfigNodeUtil.ParseValue <double>(node, "maxRange", double.MaxValue); targetBody = ConfigNodeUtil.ParseValue <CelestialBody>(node, "targetBody", (CelestialBody)null); activeVessel = ConfigNodeUtil.ParseValue <bool>(node, "activeVessel"); minCount = ConfigNodeUtil.ParseValue <int>(node, "minCount"); maxCount = ConfigNodeUtil.ParseValue <int>(node, "maxCount"); antennaType = ConfigNodeUtil.ParseValue <AntennaType?>(node, "antennaType", (AntennaType?)null); ParameterDelegate <IAntenna> .OnDelegateContainerLoad(node); CreateDelegates(); }
/// <summary> /// Starts a new thread invoking the specified method with the parameter provided. /// </summary> /// <param name="method">The method to invoke.</param> /// <param name="parameter">The method parameter.</param> public void Start(ParameterDelegate method, object parameter) { SynchronizationContext context = SynchronizationContext.Current; // if there is no synchronization, don't launch a new thread if (context != null) { // new thread to execute the Load() method for the layer new Thread(() => method.DynamicInvoke(parameter)).Start(); } else { method.DynamicInvoke(parameter); } }
protected void CreateDelegates() { if (ParameterCount < 1) { LoggingUtil.LogDebug(this, "Adding EVA parameter..."); evaParam = new ParameterDelegate <MonolithParameter>("Send a Kerbal on EVA", x => CheckParameters(MonolithState.STARTED)); AddParameter(evaParam); LoggingUtil.LogDebug(this, "Adding approach parameter..."); approachParam = new ParameterDelegate <MonolithParameter>("", x => !approachParam.hidden && CheckParameters(MonolithState.EVA)); approachParam.hidden = true; AddParameter(approachParam); LoggingUtil.LogDebug(this, "Adding 'full of stars' parameter..."); fullofstarsParam = new ParameterDelegate <MonolithParameter>("...it's full of stars!", x => !fullofstarsParam.hidden && CheckParameters(MonolithState.FULL_OF_STARS_FINAL)); fullofstarsParam.hidden = true; AddParameter(fullofstarsParam); } bool changeMade = false; if (currentState >= MonolithState.EVA) { if (approachParam.hidden) { LoggingUtil.LogDebug(this, "Unhiding approach parameter..."); approachParam.SetTitle("Approach the monolith with " + candidateName); changeMade = true; approachParam.hidden = false; } } if (currentState >= MonolithState.FULL_OF_STARS1) { if (fullofstarsParam.hidden) { LoggingUtil.LogDebug(this, "Unhiding 'full of stars' parameter..."); changeMade = true; fullofstarsParam.hidden = false; } } if (changeMade) { ContractConfigurator.ContractConfigurator.OnParameterChange.Fire(Root, this); } }
protected override void OnUpdate() { base.OnUpdate(); if (monolith == null && (HighLogic.LoadedScene == GameScenes.FLIGHT || HighLogic.LoadedScene == GameScenes.TRACKSTATION)) { monolith = ContractVesselTracker.Instance.GetAssociatedVessel("Monolith"); if (monolith != null) { monolith.vesselRanges.orbit.load = MONOLITH_DRAW_DISTANCE * 1.05f; monolith.vesselRanges.orbit.unload = MONOLITH_DRAW_DISTANCE * 1.1f; // Set monolith name to unknown if (!monolithDiscovered && monolith.vesselName != "???") { monolith.vesselName = "???"; GameEvents.onVesselRename.Fire(new GameEvents.HostedFromToAction <Vessel, string>(monolith, "Monolith", "???")); } } } if (HighLogic.LoadedScene == GameScenes.FLIGHT && FlightGlobals.ActiveVessel != null) { // Set the load distance for the monolith to be much further SetLoadDistance(); // Check our script progress ParameterDelegate <MonolithParameter> .CheckChildConditions(this, this); if (ChildChanged) { ContractConfigurator.ContractConfigurator.OnParameterChange.Fire(Root, this); ChildChanged = false; } if (currentState == MonolithState.FINISHED) { // Reset the state of the progress tree ProgressTracking.Instance.OnLoad(progressTreeBackup); // Complete the parameter SetState(ParameterState.Complete); } } }
/// <summary> /// Whether this vessel meets the parameter condition. /// </summary> /// <param name="vessel">Vessel to check</param> /// <returns>Whether the vessel meets the parameter condition(s).</returns> protected override bool VesselMeetsCondition(Vessel vessel) { LoggingUtil.LogVerbose(this, "Checking VesselMeetsCondition: " + vessel.id); // Get all the antennae VesselSatellite sat = RTCore.Instance.Satellites[vessel.id]; IEnumerable <IAntenna> antennas = sat != null ? sat.Antennas : new List <IAntenna>(); // If we're a VesselParameterGroup child, only do actual state change if we're the tracked vessel bool checkOnly = false; if (Parent is VesselParameterGroup) { checkOnly = ((VesselParameterGroup)Parent).TrackedVessel != vessel; } return(ParameterDelegate <IAntenna> .CheckChildConditions(this, antennas, checkOnly)); }
protected override string GetParameterTitle() { string output = null; if (string.IsNullOrEmpty(title)) { output = "Antenna"; if (state == ParameterState.Complete) { output += ": " + ParameterDelegate <IAntenna> .GetDelegateText(this); } } else { output = title; } return(output); }
public Parameter(string aName, Expression expression) { _Value = 0; var parts = aName.Split('.'); if (parts.Length == 1) { _NameSpace = string.Empty; _Parameter = parts[0].ToUpper(); } else if (parts.Length == 2) { _NameSpace = parts[0].ToUpper(); _Parameter = parts[1].ToUpper(); _Func = expression.GetContextValue; } else { throw new ParseException("Invalid Parameter"); } }
protected override string GetParameterTitle() { string output = null; if (string.IsNullOrEmpty(title)) { if (state == ParameterState.Complete || ParameterCount == 1) { if (ParameterCount == 1) { hideChildren = true; } output = ParameterDelegate <Vessel> .GetDelegateText(this); } } else { output = title; } return(output); }
protected override void OnParameterLoad(ConfigNode node) { try { base.OnParameterLoad(node); capacity = ConfigNodeUtil.ParseValue <bool?>(node, "capacity", (bool?)false).Value; foreach (ConfigNode childNode in node.GetNodes("RESOURCE")) { HasResource.Filter filter = new HasResource.Filter(); filter.resource = ConfigNodeUtil.ParseValue <PartResourceDefinition>(childNode, "resource"); filter.minQuantity = ConfigNodeUtil.ParseValue <double>(childNode, "minQuantity"); filter.maxQuantity = ConfigNodeUtil.ParseValue <double>(childNode, "maxQuantity", double.MaxValue); filters.Add(filter); } // Legacy if (node.HasValue("resource")) { HasResource.Filter filter = new HasResource.Filter(); filter.resource = ConfigNodeUtil.ParseValue <PartResourceDefinition>(node, "resource"); filter.minQuantity = ConfigNodeUtil.ParseValue <double>(node, "minQuantity"); filter.maxQuantity = ConfigNodeUtil.ParseValue <double>(node, "maxQuantity", double.MaxValue); filters.Add(filter); } CreateDelegates(); } finally { ParameterDelegate <Part> .OnDelegateContainerLoad(node); } }
public void Start(ParameterDelegate method, object parameter) { SynchronizationContext context = SynchronizationContext.Current; // if there is no synchronization, don't launch a new thread if (context != null) { // new thread to execute the Load() method for the layer new Thread(( object args ) => { method.DynamicInvoke(args); //// fire the OnLoadComplete event on the original thread //context.Post( new SendOrPostCallback( ( obj ) => //{ // add callback method call here if needed in future //} ), null ); }).Start(parameter); } else { method.DynamicInvoke(parameter); } }
/// <summary> /// Starts a new thread invoking the specified method with the parameter provided. /// </summary> /// <param name="method">The method to invoke.</param> /// <param name="parameter">The method parameter.</param> public void Start(ParameterDelegate method, object parameter) { }
/// <summary> /// Whether this vessel meets the parameter condition. /// </summary> /// <param name="vessel">The vessel to check</param> /// <returns>Whether the vessel meets the condition</returns> protected override bool VesselMeetsCondition(Vessel vessel) { LoggingUtil.LogVerbose(this, "Checking VesselMeetsCondition: " + vessel.id); return(ParameterDelegate <Vessel> .CheckChildConditions(this, vessel)); }
public void Start(ParameterDelegate method, object parameter) { Task.Factory.StartNew(() => method(parameter), TaskCreationOptions.LongRunning); }
public void QueueWorker(ParameterDelegate method, object parameter) { }
public void QueueWorker(ParameterDelegate method) { Task.Factory.StartNew(() => method(null)); }
public void Start(ParameterDelegate method, object parameter) { }
public void QueueWorker(ParameterDelegate method) { }
public void QueueWorker(ParameterDelegate method, object parameter) { ThreadPool.QueueUserWorkItem(new WaitCallback(method), parameter); }
public void QueueWorker(ParameterDelegate method, object parameter) { Task.Factory.StartNew(() => method(parameter)); }
public void Start(ParameterDelegate method, object parameter) { method.DynamicInvoke(parameter); }
public void QueueWorker(ParameterDelegate method) { method.DynamicInvoke(); }
public void QueueWorker(ParameterDelegate method, object parameter) { method.DynamicInvoke(parameter); }
/// <summary> /// Queues a new worker thread invoking the specified method. /// </summary> /// <param name="method">The method to invoke.</param> public void QueueWorker(ParameterDelegate method) { method.DynamicInvoke(); }
/// <summary> /// Starts a new thread invoking the specified method with the parameter provided. /// </summary> /// <param name="method">The method to invoke.</param> /// <param name="parameter">The method parameter.</param> public void Start(ParameterDelegate method, object parameter) { method.DynamicInvoke(parameter); }
/// <summary> /// Queues a new worker thread invoking the specified method. /// </summary> /// <param name="method">The method to invoke.</param> public void QueueWorker(ParameterDelegate method) { }
/// <summary> /// Queues a new worker thread invoking the specified method with the parameter provided. /// </summary> /// <param name="method">The method to invoke.</param> /// <param name="parameter">The method parameter.</param> public void QueueWorker(ParameterDelegate method, object parameter) { method.DynamicInvoke(parameter); }
/// <summary> /// Queues a new worker thread invoking the specified method with the parameter provided. /// </summary> /// <param name="method">The method to invoke.</param> /// <param name="parameter">The method parameter.</param> public void QueueWorker(ParameterDelegate method, object parameter) { }
protected void CreateDelegates() { // Filter for celestial bodies if (targetBody != null && string.IsNullOrEmpty(biome)) { AddParameter(new ParameterDelegate<Vessel>("Destination: " + targetBody.theName, subj => FlightGlobals.currentMainBody == targetBody, true)); } // Filter for biome if (!string.IsNullOrEmpty(biome)) { Biome b = new Biome(targetBody, biome); string title = b.IsKSC() ? "Location: " : "Biome: "; AddParameter(new ParameterDelegate<Vessel>(title + b, subj => CheckBiome(FlightGlobals.ActiveVessel))); } // Filter for situation if (situation != null) { AddParameter(new ParameterDelegate<Vessel>("Situation: " + situation.Value.Print(), subj => FlightGlobals.ActiveVessel != null && ScienceUtil.GetExperimentSituation(FlightGlobals.ActiveVessel) == situation)); } // Filter for location if (location != null) { AddParameter(new ParameterDelegate<Vessel>("Location: " + location, subj => FlightGlobals.ActiveVessel != null && ((location != BodyLocation.Surface) ^ FlightGlobals.ActiveVessel.LandedOrSplashed))); } // Add the experiments foreach (string exp in experiment) { string experimentStr = string.IsNullOrEmpty(exp) ? "Any" : ExperimentName(exp); ContractParameter experimentParam = AddParameter(new ParameterDelegate<Vessel>("Experiment: " + experimentStr, subj => recoveryDone.ContainsKey(exp))); // Add the subject ContractParameter subjectParam = new ParameterDelegate<Vessel>("", subj => true); subjectParam.ID = exp + "Subject"; experimentParam.AddParameter(subjectParam); // Filter for recovery if (recoveryMethod != ScienceRecoveryMethod.None) { ContractParameter recoveryParam = experimentParam.AddParameter(new ParameterDelegate<Vessel>("Recovery: " + RecoveryMethod(exp).Print(), subj => false)); } } }
protected void CreateDelegates() { if (ParameterCount < 1) { LoggingUtil.LogDebug(this, "Adding EVA parameter..."); evaParam = new ParameterDelegate<MonolithParameter>("Send a Kerbal on EVA", x => CheckParameters(MonolithState.STARTED)); AddParameter(evaParam); LoggingUtil.LogDebug(this, "Adding approach parameter..."); approachParam = new ParameterDelegate<MonolithParameter>("", x => !approachParam.hidden && CheckParameters(MonolithState.EVA)); approachParam.hidden = true; AddParameter(approachParam); LoggingUtil.LogDebug(this, "Adding 'full of stars' parameter..."); fullofstarsParam = new ParameterDelegate<MonolithParameter>("...it's full of stars!", x => !fullofstarsParam.hidden && CheckParameters(MonolithState.FULL_OF_STARS_FINAL)); fullofstarsParam.hidden = true; AddParameter(fullofstarsParam); } bool changeMade = false; if (currentState >= MonolithState.EVA) { if (approachParam.hidden) { LoggingUtil.LogDebug(this, "Unhiding approach parameter..."); approachParam.SetTitle("Approach the monolith with " + candidateName); changeMade = true; approachParam.hidden = false; } } if (currentState >= MonolithState.FULL_OF_STARS1) { if (fullofstarsParam.hidden) { LoggingUtil.LogDebug(this, "Unhiding 'full of stars' parameter..."); changeMade = true; fullofstarsParam.hidden = false; } } if (changeMade) { ContractConfigurator.ContractConfigurator.OnParameterChange.Fire(Root, this); } }