public void CancelEvents(EngineValue _engineValue)
{
for (int i = 0; i < valueEvents.Length; i++)
{
valueEvents[i].CancelEvent(_engineValue);
}
}
public static ListValue PartList(this IShipconstruct vessel, string partType, SharedObjects sharedObj)
{
var list = new ListValue();
var partList = vessel.Parts.ToList();
switch (partType.ToUpper())
{
case "RESOURCES":
list = ResourceValue.PartsToList(partList);
break;
case "PARTS":
list = PartValue.PartsToList(partList, sharedObj);
break;
case "ENGINES":
list = EngineValue.PartsToList(partList, sharedObj);
break;
case "SENSORS":
list = SensorValue.PartsToList(partList, sharedObj);
break;
case "ELEMENTS":
list = ElementValue.PartsToList(partList);
break;
case "DOCKINGPORTS":
list = DockingPortValue.PartsToList(partList, sharedObj);
break;
}
return(list);
}
public MaterialEngineParameter(MaterialEngineParameter engineParam)
{
_effectParameter = engineParam.EffectParameter;
_isSemantic = engineParam.IsSemantic;
_engineValue = engineParam.EngineValue;
_name = engineParam.Name;
}
public MaterialEngineParameter(IEffectParameter parameter, String name, bool isSemantic, EngineValue value)
{
_effectParameter = parameter;
_isSemantic = isSemantic;
_name = name;
_engineValue = value;
}
public MaterialEngineParameter(MaterialEngineParameter engineParam, String name, IEffectParameter replacement)
{
_effectParameter = replacement;
_isSemantic = engineParam.IsSemantic;
_engineValue = engineParam.EngineValue;
_name = name;
}
/// <summary>
/// Convenience method for retrieving the float value corresponding to the specified engine value.
/// </summary>
/// <param name="valueEnum">EngineValue enum</param>
/// <param name="value">float value to store result</param>
/// <exception cref="System.InvalidOperationException">Thrown if the engine value specified does not correspond to a float value.</exception>
public void GetValue(EngineValue valueEnum, out float value)
{
switch (valueEnum)
{
case EngineValue.AspectRatio:
value = this.AspectRatio;
break;
case EngineValue.Time:
value = this.Time;
break;
case EngineValue.TimePerFrame:
value = this.TimePerFrame;
break;
case EngineValue.FrameRate:
value = this.FrameRate;
break;
case EngineValue.RandomFloat:
value = this.RandomFloat;
break;
default:
throw new InvalidOperationException("Engine value is not a float!");
}
}
public void SetEngineParameter(String paramName, bool isSemantic, EngineValue engineValue)
{
if (IsValid)
{
IEffectParameter param = null;
if (isSemantic)
{
param = _effect.Parameters.GetParameterBySemantic(paramName);
}
else
{
param = _effect.Parameters[paramName];
}
//Doesn't exist, don't create an entry
if (param == null)
{
return;
}
MaterialEngineParameter engineParam = new MaterialEngineParameter(param, paramName, isSemantic, engineValue);
_cachedEngineParameters[paramName] = engineParam;
}
else
{
throw new ArgumentNullException("Material does not have a valid effect loaded, cannot set engine parameter. Call LoadEffect() first.");
}
}
protected override void LoadDefaultData()
{
base.LoadDefaultData();
//get ammo value from container
ammoValue = engineValueContainer.GetEngineValue
(Data.engineValueSelections[Data.ammoSelection].valueSelection.valueData.ID);
}
public virtual void SyncEngineValue(EngineValue _engineValue)
{
SetMinMaxValue(_engineValue.Data.FloatMinValue, _engineValue.Data.FloatMaxValue);
SetCurValue(_engineValue.Value);
connectedValue = _engineValue;
connectedValue.valueChanged += SetCurValue;
connectedValue.minMaxChanged += SetMinMaxValue;
}
public virtual void SyncEngineValue(EngineValue _engineValue, UILayoutMaster _master, int _ind)
{
var val = GetEngineValueUI(_master, _ind);
if (val)
{
val.SyncEngineValue(_engineValue);
}
}
public virtual EngineValue CreateEngineValue()
{
var val = new EngineValue
{
MinValue = MinValue,
MaxValue = MaxValue,
Value = Value
};
return(val);
}
/// <summary>
/// Convenience method for retrieving the int value corresponding to the specified engine value.
/// </summary>
/// <param name="valueEnum">EngineValue enum</param>
/// <param name="value">int value to store result</param>
/// <exception cref="System.InvalidOperationException">Thrown if the engine value specified does not correspond to an int value.</exception>
public void GetValue(EngineValue valueEnum, out int value)
{
switch (valueEnum)
{
case EngineValue.RandomInt:
value = this.RandomInt;
break;
default:
throw new InvalidOperationException("Engine value is not an int!");
}
}
/// <summary>
/// Convenience method for retrieving the Vector4 value corresponding to the specified engine value.
/// </summary>
/// <param name="valueEnum">EngineValue enum</param>
/// <param name="value">fVector4 value to store result</param>
/// <exception cref="System.InvalidOperationException">Thrown if the engine value specified does not correspond to a Vector4 value.</exception>
public void GetValue(EngineValue valueEnum, out Vector4 value)
{
switch (valueEnum)
{
case EngineValue.Viewport:
value = this.Viewport;
break;
default:
throw new InvalidOperationException("Engine value is not a Vector4!");
}
}
/// <summary>
/// Convenience method for retrieving the Matrix value corresponding to the specified engine value.
/// </summary>
/// <param name="valueEnum">EngineValue enum</param>
/// <param name="value">Matrix value to store result</param>
/// <exception cref="System.InvalidOperationException">Thrown if the engine value specified does not correspond to a Matrix value.</exception>
public void GetValue(EngineValue valueEnum, out Matrix value)
{
switch (valueEnum)
{
case EngineValue.WorldMatrix:
value = this.WorldMatrix;
break;
case EngineValue.WorldMatrixInverse:
value = this.WorldMatrixInverse;
break;
case EngineValue.WorldInverseTranspose:
value = this.WorldInverseTranspose;
break;
case EngineValue.ViewMatrix:
value = this.ViewMatrix;
break;
case EngineValue.ViewMatrixInverse:
value = this.ViewMatrixInverse;
break;
case EngineValue.ProjectionMatrix:
value = this.ProjectionMatrix;
break;
case EngineValue.ProjectionMatrixInverse:
value = this.ProjectionMatrixInverse;
break;
case EngineValue.WorldViewMatrix:
value = this.WorldViewMatrix;
break;
case EngineValue.ViewProjectionMatrix:
value = this.ViewProjectionMatrix;
break;
case EngineValue.WorldViewProjection:
value = this.WorldViewProjection;
break;
default:
throw new InvalidOperationException("Engine value is not a Matrix!");
}
}
/// <summary>
/// Convenience method for retrieving the Vector2 value corresponding to the specified engine value.
/// </summary>
/// <param name="valueEnum">EngineValue enum</param>
/// <param name="value">Vector2 value to store result</param>
/// <exception cref="System.InvalidOperationException">Thrown if the engine value specified does not correspond to a Vector2 value.</exception>
public void GetValue(EngineValue valueEnum, out Vector2 value)
{
switch (valueEnum)
{
case EngineValue.Resolution:
value = this.Resolution;
break;
case EngineValue.FrustumNearFar:
value = this.FrustumNearFar;
break;
default:
throw new InvalidOperationException("Engine value is not a Vector2!");
}
}
private kList GetEngineList(SharedObjects shared)
{
var list = new kList();
list.AddColumn("ID", 12, ColumnAlignment.Left);
list.AddColumn("Stage", 8, ColumnAlignment.Left);
list.AddColumn("Name", 28, ColumnAlignment.Left);
ListValue partList = EngineValue.PartsToList(shared.Vessel.Parts, shared);
foreach (Structure structure in partList)
{
var part = (PartValue)structure;
list.AddItem(part.Part.uid(), part.Part.inverseStage, part.Part.partInfo.name);
}
return(list);
}
private ScalarValue GetIgnitionChance(EngineValue engine)
{
TestFlightCore.TestFlightCore coreMod = GetCoreModule(engine);
if (coreMod != null)
{
foreach (var module in engine.Part.Modules)
{
var relMod = module as TestFlightFailure_IgnitionFail;
if (relMod != null)
{
double ignitionChance = relMod.baseIgnitionChance.Evaluate(coreMod.GetInitialFlightData());
if (ignitionChance > 0)
{
return(ignitionChance);
}
}
}
}
return(-1f);
}
/// <summary>
/// Convenience method for retrieving the Vector3 value corresponding to the specified engine value.
/// </summary>
/// <param name="valueEnum">EngineValue enum</param>
/// <param name="value">Vector3 value to store result</param>
/// <exception cref="System.InvalidOperationException">Thrown if the engine value specified does not correspond to a Vector3 value.</exception>
public void GetValue(EngineValue valueEnum, out Vector3 value)
{
switch (valueEnum)
{
case EngineValue.CameraDirection:
value = this.CameraDirection;
break;
case EngineValue.CameraRight:
value = this.CameraRight;
break;
case EngineValue.CameraPosition:
value = this.CameraPosition;
break;
case EngineValue.CameraUp:
value = this.CameraUp;
break;
default:
throw new InvalidOperationException("Engine value is not a Vector3!");
}
}
public void SetEngineParameter(String paramName, EngineValue engineValue)
{
SetEngineParameter(paramName, false, engineValue);
}
private void ConstructPart(global::Part part, PartValue parent, DecouplerValue decoupler)
{
if (part.State == PartStates.DEAD || part.transform == null)
{
return;
}
PartValue self = null;
foreach (var module in part.Modules)
{
var engine = module as IEngineStatus;
if (engine != null)
{
self = new EngineValue(Shared, part, parent, decoupler);
break;
}
if (module is IStageSeparator)
{
var dock = module as ModuleDockingNode;
if (dock != null)
{
var port = new DockingPortValue(Shared, part, parent, decoupler, dock);
self = port;
dockingPorts.Add(port);
if (!module.StagingEnabled())
{
break;
}
decoupler = port;
decouplers.Add(decoupler);
}
else
{
// ignore anything with staging disabled and continue the search
// this can e.g. be heat shield or some sensor with integrated decoupler
if (!module.StagingEnabled())
{
continue;
}
if (module is LaunchClamp)
{
self = decoupler = new LaunchClampValue(Shared, part, parent, decoupler);
}
else if (module is ModuleDecouple || module is ModuleAnchoredDecoupler)
{
self = decoupler = new DecouplerValue(Shared, part, parent, decoupler);
}
else // ModuleServiceModule ?
{
continue; // rather continue the search
}
decouplers.Add(decoupler);
}
// ignore leftover decouplers
if (decoupler == null || decoupler.Part.inverseStage >= StageManager.CurrentStage)
{
break;
}
// check if we just created closer decoupler (see StageValues.CreatePartSet)
if (nextDecoupler == null || decoupler.Part.inverseStage > nextDecoupler.Part.inverseStage)
{
nextDecoupler = decoupler;
}
break;
}
var sensor = module as ModuleEnviroSensor;
if (sensor != null)
{
self = new SensorValue(Shared, part, parent, decoupler, sensor);
break;
}
}
if (self == null)
{
self = new PartValue(Shared, part, parent, decoupler);
}
if (rootPart == null)
{
rootPart = self;
}
partCache[part] = self;
allParts.Add(self);
foreach (var child in part.children)
{
ConstructPart(child, self, decoupler);
}
self.Children.IsReadOnly = true;
}
public void SyncEvent(EngineValue _engineValue)
{
_engineValue.valueChanged += CheckEvent;
}
public void CancelEvent(EngineValue _engineValue)
{
_engineValue.valueChanged -= CheckEvent;
}
private void ConstructPart(global::Part part, PartValue parent, DecouplerValue decoupler)
{
if (part.State == PartStates.DEAD || part.transform == null)
{
return;
}
// Modules can be in any order, so to enforce some sort of priority for parts which are multiple types,
// gather all potential modules and then select from those valid.
IEngineStatus engine = null;
ModuleRCS rcs = null;
PartValue separator = null;
ModuleEnviroSensor sensor = null;
foreach (var module in part.Modules)
{
if (module is IEngineStatus)
{
engine = module as IEngineStatus;
}
else if (module is ModuleRCS)
{
rcs = module as ModuleRCS;
}
else if (module is IStageSeparator)
{
var dock = module as ModuleDockingNode;
if (dock != null)
{
var port = new DockingPortValue(Shared, part, parent, decoupler, dock);
separator = port;
dockingPorts.Add(port);
if (!module.StagingEnabled())
{
continue;
}
decoupler = port;
decouplers.Add(decoupler);
}
// ignore anything with staging disabled and continue the search
// this can e.g. be heat shield or some sensor with integrated decoupler
else
{
if (!module.StagingEnabled())
{
continue;
}
if (module is LaunchClamp)
{
separator = decoupler = new LaunchClampValue(Shared, part, parent, decoupler);
}
else if (module is ModuleDecouple || module is ModuleAnchoredDecoupler)
{
separator = decoupler = new DecouplerValue(Shared, part, parent, decoupler);
}
else // ModuleServiceModule ?
{
continue; // rather continue the search
}
decouplers.Add(decoupler);
}
// ignore leftover decouplers
if (decoupler == null || decoupler.Part.inverseStage >= StageManager.CurrentStage)
{
continue;
}
// check if we just created closer decoupler (see StageValues.CreatePartSet)
if (nextDecoupler == null || decoupler.Part.inverseStage > nextDecoupler.Part.inverseStage)
{
nextDecoupler = decoupler;
}
}
else if (module is ModuleEnviroSensor)
{
sensor = module as ModuleEnviroSensor;
}
}
// Select part value in priority order
PartValue self;
if (engine != null)
{
self = new EngineValue(Shared, part, parent, decoupler);
}
else if (rcs != null)
{
self = new RCSValue(Shared, part, parent, decoupler, rcs);
}
else if (separator != null)
{
self = separator;
}
else if (sensor != null)
{
self = new SensorValue(Shared, part, parent, decoupler, sensor);
}
else
{
self = new PartValue(Shared, part, parent, decoupler);
}
if (rootPart == null)
{
rootPart = self;
}
partCache[part] = self;
allParts.Add(self);
foreach (var child in part.children)
{
ConstructPart(child, self, decoupler);
}
self.Children.IsReadOnly = true;
}
