public Base6Directions.Direction TransformDirection(Base6Directions.Direction baseDirection)
{
Base6Directions.Axis axis = Base6Directions.GetAxis(baseDirection);
int num = (int)(baseDirection % Base6Directions.Direction.Left);
switch (axis)
{
case Base6Directions.Axis.ForwardBackward:
if (num != 1)
{
return(this.Forward);
}
return(Base6Directions.GetFlippedDirection(this.Forward));
case Base6Directions.Axis.LeftRight:
if (num != 1)
{
return(this.Left);
}
return(Base6Directions.GetFlippedDirection(this.Left));
}
if (num != 1)
{
return(this.Up);
}
return(Base6Directions.GetFlippedDirection(this.Up));
}
public Base6Directions.Direction TransformDirectionInverse(Base6Directions.Direction baseDirection)
{
Base6Directions.Axis axis = Base6Directions.GetAxis(baseDirection);
if (axis == Base6Directions.GetAxis(this.Forward))
{
if (baseDirection != this.Forward)
{
return(Base6Directions.Direction.Backward);
}
return(Base6Directions.Direction.Forward);
}
if (axis == Base6Directions.GetAxis(this.Left))
{
if (baseDirection != this.Left)
{
return(Base6Directions.Direction.Right);
}
return(Base6Directions.Direction.Left);
}
if (baseDirection != this.Up)
{
return(Base6Directions.Direction.Down);
}
return(Base6Directions.Direction.Up);
}
public long AxisValue(Base6Directions.Axis axis)
{
if (axis == Base6Directions.Axis.ForwardBackward)
{
return(this.Z);
}
if (axis == Base6Directions.Axis.LeftRight)
{
return(this.X);
}
return(this.Y);
}
public IntervalSampler(double min, double max, double weightMultiplier, Base6Directions.Axis axis)
{
m_min = min;
m_max = max;
m_axis = axis;
m_weightMult = weightMultiplier;
m_totalWeight = weightMultiplier * (m_max - m_min);
m_entries = new List <SamplingEntry>();
m_entries.Add(new SamplingEntry(m_max, null, m_totalWeight));
}
public int AxisValue(Base6Directions.Axis axis)
{
if (axis == Base6Directions.Axis.ForwardBackward)
{
return(Z);
}
else if (axis == Base6Directions.Axis.LeftRight)
{
return(X);
}
Debug.Assert(axis == Base6Directions.Axis.UpDown, "Invalid axis in Vector3I.AxisProjection!");
return(Y);
}
/// <summary>
/// Returns the direction that this orientation transforms to baseDirection
/// </summary>
public Base6Directions.Direction TransformDirectionInverse(Base6Directions.Direction baseDirection)
{
Base6Directions.Axis axis = Base6Directions.GetAxis(baseDirection);
if (axis == Base6Directions.GetAxis(Forward))
{
return(baseDirection == Forward ? Base6Directions.Direction.Forward : Base6Directions.Direction.Backward);
}
if (axis == Base6Directions.GetAxis(Left))
{
return(baseDirection == Left ? Base6Directions.Direction.Left : Base6Directions.Direction.Right);
}
Debug.Assert(axis == Base6Directions.GetAxis(Up), "Direction invalid in MyBlockOrientation");
return(baseDirection == Up ? Base6Directions.Direction.Up : Base6Directions.Direction.Down);
}
/// <summary>
/// Returns the direction baseDirection will point to after transformation
/// </summary>
public Base6Directions.Direction TransformDirection(Base6Directions.Direction baseDirection)
{
Base6Directions.Axis axis = Base6Directions.GetAxis(baseDirection);
int flip = ((int)baseDirection % 2);
if (axis == Base6Directions.Axis.ForwardBackward)
{
return(flip == 1 ? Base6Directions.GetFlippedDirection(Forward) : Forward);
}
if (axis == Base6Directions.Axis.LeftRight)
{
return(flip == 1 ? Base6Directions.GetFlippedDirection(Left) : Left);
}
Debug.Assert(axis == Base6Directions.Axis.UpDown, "Axis invalid in MyBlockOrientation");
return(flip == 1 ? Base6Directions.GetFlippedDirection(Up) : Up);
}
private void SelectMinMax(ref BoundingBoxD bb, Base6Directions.Axis axis, out double min, out double max)
{
if (axis == Base6Directions.Axis.UpDown)
{
min = bb.Min.Y;
max = bb.Max.Y;
}
else if (axis == Base6Directions.Axis.ForwardBackward)
{
min = bb.Min.Z;
max = bb.Max.Z;
}
else
{
System.Diagnostics.Debug.Assert(axis == Base6Directions.Axis.LeftRight, "Invalid Axis value");
min = bb.Min.X;
max = bb.Max.X;
}
return;
}
private IntervalSampler(IntervalSampler other, double t, bool clone)
{
m_min = other.m_min;
m_max = other.m_max;
m_axis = other.m_axis;
m_weightMult = other.m_weightMult;
m_totalWeight = other.m_totalWeight;
m_entries = new List <SamplingEntry>(other.m_entries);
for (int i = 0; i < other.m_entries.Count; ++i)
{
m_entries[i] = new SamplingEntry(other.m_entries[i]);
}
Multiply(t);
// If we are not cloning, we are splitting, so we have to multiply the remnant as well
if (!clone)
{
other.Multiply(1.0 - t);
}
}
public MyGravitonThruster(IMyGravityGenerator gravGen, List <SharedMass> allMass)
{
m_gravGen = gravGen;
//m_enabled = m_gravGen.Enabled;
//Correction de l'orientation du thruster (pour qu'ils poussent tous dans la même direction
switch (m_gravGen.Orientation.Up)
{
case Base6Directions.Direction.Right:
axe = Base6Directions.Axis.LeftRight;
m_orientationThrusterCorrection = -1;
break;
case Base6Directions.Direction.Left:
axe = Base6Directions.Axis.LeftRight;
m_orientationThrusterCorrection = 1;
break;
case Base6Directions.Direction.Up:
axe = Base6Directions.Axis.UpDown;
m_orientationThrusterCorrection = -1;
break;
case Base6Directions.Direction.Down:
axe = Base6Directions.Axis.UpDown;
m_orientationThrusterCorrection = 1;
break;
case Base6Directions.Direction.Forward:
axe = Base6Directions.Axis.ForwardBackward;
m_orientationThrusterCorrection = 1;
break;
case Base6Directions.Direction.Backward:
axe = Base6Directions.Axis.ForwardBackward;
m_orientationThrusterCorrection = -1;
break;
}
Vector3 gravityFeild = new Vector3(); //On réoriente le vector "Gravity feild" pour que sa zone corresponde aux coordonées des autres elements de la grille
switch (axe)
{
case Base6Directions.Axis.LeftRight:
gravityFeild.X = m_gravGen.FieldSize.Y / 5f; //On divise par 2.5 car 1 bloc fait 2.5 de coté, et aussi par 2, car on souhaite avoir le rayon à la place du diamètre diamètre. Donc 5
if (m_gravGen.Orientation.Forward <= Base6Directions.Direction.Backward) // ForwardBackward
{
gravityFeild.Y = m_gravGen.FieldSize.X / 5f;
gravityFeild.Z = m_gravGen.FieldSize.Z / 5f;
}
else // UpDown
{
gravityFeild.Y = m_gravGen.FieldSize.Z / 5f;
gravityFeild.Z = m_gravGen.FieldSize.X / 5f;
}
break;
case Base6Directions.Axis.UpDown:
gravityFeild.Y = m_gravGen.FieldSize.Y / 5f;
if (m_gravGen.Orientation.Forward <= Base6Directions.Direction.Backward) // ForwardBackward
{
gravityFeild.X = m_gravGen.FieldSize.X / 5f;
gravityFeild.Z = m_gravGen.FieldSize.Z / 5f;
}
else // LeftRight
{
gravityFeild.X = m_gravGen.FieldSize.Z / 5f;
gravityFeild.Z = m_gravGen.FieldSize.X / 5f;
}
break;
case Base6Directions.Axis.ForwardBackward:
gravityFeild.Z = m_gravGen.FieldSize.Y / 5f;
if (m_gravGen.Orientation.Forward <= Base6Directions.Direction.Right) // LeftRight
{
gravityFeild.X = m_gravGen.FieldSize.X / 5f;
gravityFeild.Y = m_gravGen.FieldSize.Z / 5f;
}
else // UpDown
{
gravityFeild.X = m_gravGen.FieldSize.Z / 5f;
gravityFeild.Y = m_gravGen.FieldSize.X / 5f;
}
break;
}
//On récupère la liste des masses artificielles qui sont dans le champ de gravité
Vector3 distance = new Vector3();
m_position = new Vector3D(0, 0, 0);
IMyVirtualMass mass;
foreach (SharedMass shrMass in allMass)
{
mass = shrMass.mass;
distance = mass.Position - m_gravGen.Position;
if (Math.Abs(distance.X) <= gravityFeild.X &&
Math.Abs(distance.Y) <= gravityFeild.Y &&
Math.Abs(distance.Z) <= gravityFeild.Z)
{
m_mass.Add(shrMass);
m_position += mass.Position * mass.VirtualMass;
}
}
m_artificialMass_kg = m_mass.Sum(shrmass => shrmass.mass.VirtualMass);
m_maximumThrust_kN = 9.81f * m_artificialMass_kg / 1000;
if (m_artificialMass_kg > 0)
{
m_position = (m_position * 2.5D) / m_artificialMass_kg;
}
else
{
m_position = m_gravGen.Position * 2.5D;
}
}
private IntervalSampler(IntervalSampler other, double t, bool clone)
{
m_min = other.m_min;
m_max = other.m_max;
m_axis = other.m_axis;
m_weightMult = other.m_weightMult;
m_totalWeight = other.m_totalWeight;
m_entries = new List<SamplingEntry>(other.m_entries);
for (int i = 0; i < other.m_entries.Count; ++i)
{
m_entries[i] = new SamplingEntry(other.m_entries[i]);
}
Multiply(t);
// If we are not cloning, we are splitting, so we have to multiply the remnant as well
if (!clone)
{
other.Multiply(1.0 - t);
}
}
public IntervalSampler(double min, double max, double weightMultiplier, Base6Directions.Axis axis)
{
m_min = min;
m_max = max;
m_axis = axis;
m_weightMult = weightMultiplier;
m_totalWeight = weightMultiplier * (m_max - m_min);
m_entries = new List<SamplingEntry>();
m_entries.Add(new SamplingEntry(m_max, null, m_totalWeight));
}
public void Subtract(ref BoundingBoxD originalBox, ref BoundingBoxD bb)
{
double min, max;
SelectMinMax(ref bb, m_axis, out min, out max);
bool minInserted = false;
double prevLimit = m_min;
double cumul = 0.0;
for (int i = 0; i < m_entries.Count; ++i)
{
SamplingEntry entry = m_entries[i];
if (!minInserted)
{
if (entry.UpperLimit >= min)
{
if (entry.UpperLimit == min)
{
minInserted = true;
}
else // (entry.UpperLimit > min)
{
if (prevLimit == min)
{
minInserted = true;
i--;
continue;
}
minInserted = true;
SamplingEntry insertedEntry = SamplingEntry.Divide(ref entry, prevLimit, cumul, m_weightMult, min);
m_entries[i] = entry;
m_entries.Insert(i, insertedEntry);
entry = insertedEntry;
}
}
}
else
{
if (prevLimit < max)
{
if (entry.UpperLimit > max)
{
SamplingEntry insertedEntry = SamplingEntry.Divide(ref entry, prevLimit, cumul, m_weightMult, max);
m_entries[i] = entry;
m_entries.Insert(i, insertedEntry);
entry = insertedEntry;
}
if (entry.UpperLimit <= max)
{
if (entry.Sampler == null)
{
if (m_axis == Base6Directions.Axis.ForwardBackward)
{
entry.Full = true;
entry.CumulativeWeight = cumul;
}
else
{
if (entry.Full == false) // Full entries can be kept as they are
{
Base6Directions.Axis nextAxis = m_axis == Base6Directions.Axis.LeftRight ? Base6Directions.Axis.UpDown : Base6Directions.Axis.ForwardBackward;
double min2, max2;
SelectMinMax(ref originalBox, nextAxis, out min2, out max2);
double range = m_max - m_min;
double volume = m_weightMult * range;
double relativeWidth = (entry.UpperLimit - prevLimit) / range;
double newRange = max2 - min2;
entry.Sampler = new IntervalSampler(min2, max2, (volume * relativeWidth) / newRange, nextAxis);
}
}
}
if (entry.Sampler != null)
{
entry.Sampler.Subtract(ref originalBox, ref bb);
entry.CumulativeWeight = cumul + entry.Sampler.TotalWeight;
}
m_entries[i] = entry;
}
}
else
{
if (entry.Sampler == null)
{
if (entry.Full)
{
entry.CumulativeWeight = cumul;
}
else
{
entry.CumulativeWeight = cumul + (entry.UpperLimit - prevLimit) * m_weightMult;
}
}
else
{
entry.CumulativeWeight = cumul + entry.Sampler.TotalWeight;
}
m_entries[i] = entry;
}
}
prevLimit = entry.UpperLimit;
cumul = entry.CumulativeWeight;
}
m_totalWeight = cumul;
}
