public override string ToString()
{
string s = string.Empty;
IStringConvertibleMatrix matrix = ConstrainedValue;
if (matrix != null && matrix.ColumnNames.Count() != 0)
{
s += constraintColumn + " ";
}
else
{
return("ComparisonConstraint");
}
if (ConstraintOperation != null)
{
s += ConstraintOperation.ToString() + " ";
}
if (ConstraintData != null)
{
s += ConstraintData.GetValue();
}
else
{
s += "null";
}
return(s);
}
public void WriteToStream(Stream stream)
{
var writer = new BinaryWriter(stream);
writer.Write(Type);
writer.Write(Size);
writer.Write(NameHash);
writer.Write((uint)ConstraintType);
writer.Write(NameUnused);
writer.Write(BodyANameUnused);
writer.Write(BodyAIndex);
writer.Write(BodyAOrient);
writer.Write(BodyAPos);
writer.Write(BodyBNameUnused);
writer.Write(BodyBIndex);
writer.Write(BodyBOrient);
writer.Write(BodyBPos);
writer.Write(Threshold);
ConstraintData.WriteToStream(stream);
}
protected override bool Check(object constrainedMember)
{
if (constrainedMember == null)
{
return(false);
}
Type constrainedMemberType = constrainedMember.GetType();
bool compareValue = ConstraintData.IsAssignableFrom(constrainedMemberType);
bool result;
if (ConstraintOperation == ConstraintOperation.IsTypeCompatible)
{
result = compareValue;
}
else if (ConstraintOperation == ConstraintOperation.IsTypeNotCompatible)
{
result = !compareValue;
}
else
{
throw new InvalidOperationException("Constraint operation " + this.ConstraintOperation + " is not defined for TypeCompatibilityConstraint.");
}
return(result);
}
private static bool RandomRecursion(Board work, ConstraintData data, List <int> Digits, int Index)
{
if (Index == 81)
{
return(true);
}
var loc = new Location(Index);
if (work[loc] > 0)
{
return(RandomRecursion(work, data, Digits, Index + 1));
}
foreach (int test in Digits)
{
if (!data.DigitInRow[test, loc.Row] && !data.DigitInColumn[test, loc.Column] && !data.DigitInZone[test, loc.Zone])
{
work[loc] = test;
data.DigitInRow[test, loc.Row] = data.DigitInColumn[test, loc.Column] = data.DigitInZone[test, loc.Zone] = true;
if (RandomRecursion(work, data, Digits, Index + 1))
{
return(true);
}
data.DigitInRow[test, loc.Row] = data.DigitInColumn[test, loc.Column] = data.DigitInZone[test, loc.Zone] = false;
}
}
work[loc] = 0;
return(false);
}
private static bool BruteForceRecursion(Board work, ConstraintData data, int Index)
{
if (Index == 81)
return true;
if (work[Index] > 0)
return BruteForceRecursion(work, data, Index + 1);
var loc = new Location(Index);
for (int i = 1; i < 10; i++)
{
if (!data.DigitInRow[i, loc.Row] && !data.DigitInColumn[i, loc.Column] && !data.DigitInZone[i, loc.Zone])
{
work[loc] = i;
data.DigitInRow[i, loc.Row] = data.DigitInColumn[i, loc.Column] = data.DigitInZone[i, loc.Zone] = true;
if (BruteForceRecursion(work, data, Index + 1))
return true;
data.DigitInRow[i, loc.Row] = data.DigitInColumn[i, loc.Column] = data.DigitInZone[i, loc.Zone] = false;
}
}
work[Index] = 0;
return false;
}
public override string ToString()
{
string s = string.Empty;
if (ConstrainedValue != null)
{
s += ConstrainedValue.GetVariableName(ConstraintColumn) + " ";
}
if (ConstraintOperation != null)
{
s += ConstraintOperation.ToString() + " ";
}
if (ConstraintData != null)
{
s += ConstraintData.ToString();
}
else
{
s += "null";
}
s += ".";
return(s);
}
public XElement WriteToXml()
{
var propertyRoot = new XElement("Property");
PropertyManager.WritePropertyInfoToXml(propertyRoot, Type, Size, NameHash, "template", "constraint template");
var data = new XElement("Data");
data.Add(new XElement("ConstraintType", (uint)ConstraintType));
data.Add(new XElement("NameUnused", NameUnused));
data.Add(new XElement("BodyANameUnused", BodyANameUnused));
data.Add(new XElement("BodyAIndex", BodyAIndex));
data.Add(BodyAOrient.ToXElement("BodyAOrient"));
data.Add(BodyAPos.ToXElement("BodyAPos"));
data.Add(new XElement("BodyBNameUnused", BodyBNameUnused));
data.Add(new XElement("BodyBIndex", BodyBIndex));
data.Add(BodyBOrient.ToXElement("BodyBOrient"));
data.Add(BodyBPos.ToXElement("BodyBPos"));
data.Add(new XElement("Threshold", Threshold));
if (ConstraintData != null)
{
data.Add(ConstraintData.WriteToXml());
}
else
{
data.Add(new XElement("ConstraintData", "null"));
}
propertyRoot.Add(data);
return(propertyRoot);
}
private static bool RandomRecursion(Board work, ConstraintData data, List<int> Digits, int Index)
{
if (Index == 81)
return true;
var loc = new Location(Index);
if (work[loc] > 0)
return RandomRecursion(work, data, Digits, Index + 1);
foreach (int test in Digits)
{
if (!data.DigitInRow[test, loc.Row] && !data.DigitInColumn[test, loc.Column] && !data.DigitInZone[test, loc.Zone])
{
work[loc] = test;
data.DigitInRow[test, loc.Row] = data.DigitInColumn[test, loc.Column] = data.DigitInZone[test, loc.Zone] = true;
if (RandomRecursion(work, data, Digits, Index + 1))
return true;
data.DigitInRow[test, loc.Row] = data.DigitInColumn[test, loc.Column] = data.DigitInZone[test, loc.Zone] = false;
}
}
work[loc] = 0;
return false;
}
/// <summary>
/// Attempts to fill the calling <see cref="Board"/> instance with numbers.
/// The original instance remains unchanged
/// </summary>
/// <returns>Either a new instance of <see cref="Board"/> or, if unsuccessful, null</returns>
public Board Sequential()
{
var work = new Board(_parent);
ConstraintData data = new ConstraintData(work);
if (BruteForceRecursion(work, data, 0))
return work;
return null;
}
/// <summary>
/// Attempts to fill the calling <see cref="Board"/> instance with numbers.
/// The original instance remains unchanged
/// </summary>
/// <param name="Stream">If you already have a <see cref="Random"/> stream, you may provide it here</param>
/// <returns>Either a new instance of <see cref="Board"/> or, if unsuccessful, null</returns>
public Board Randomized(Random Stream)
{
var result = new Board(_parent);
ConstraintData data = new ConstraintData(result);
var digits = new List<int>();
for (int i = 1; i < 10; i++)
digits.Insert(Stream.Next(digits.Count), i);
if (RandomRecursion(result, data, digits, 0))
return result;
return null;
}
private void Start()
{
m_clothParticleObjects = GetComponentsInChildren <ClothParticleObject>();
ClothParticleConstraints[] clothParticleConstraints = GetComponentsInChildren <ClothParticleConstraints>();
ParticleClothSettings particleSettings = new ParticleClothSettings();
ParticleData[] particleDatas = new ParticleData[m_clothParticleObjects.Length];
Stack <ConstraintData> constraintDatas = new Stack <ConstraintData>();
for (int i = 0; i < m_clothParticleObjects.Length; i++)
{
ClothParticleObject obj = m_clothParticleObjects[i];
obj.Index = i;
particleDatas[i] = obj.ToParticleData();
}
for (int i = 0; i < clothParticleConstraints.Length; i++)
{
ClothParticleConstraints obj = clothParticleConstraints[i];
int indexA = obj.GetComponent <ClothParticleObject>().Index;
for (int j = 0; j < obj.OtherClothParticles.Length; j++)
{
if (obj.ValidConnection(j))
{
ClothParticleObject other = obj.OtherClothParticles[j];
ConstraintData constraintData = new ConstraintData();
constraintData.ParticleAIndex = indexA;
constraintData.ParticleBIndex = other.Index;
constraintData.Length = Vector3.Distance(obj.transform.position, other.transform.position);
constraintDatas.Push(constraintData);
}
}
}
particleSettings.SetGravity(m_gravity.x, m_gravity.y, m_gravity.z);
particleSettings.SetParticles(particleDatas, constraintDatas.ToArray());
//gather collision Objects
ICollisionIntegrator[] collisions = GetComponentsInChildren <ICollisionIntegrator>();
ICollisionObject[] collisionObjects = new ICollisionObject[collisions.Length];
for (int i = 0; i < collisions.Length; i++)
{
collisionObjects[i] = collisions[i].CollisionObject();
}
particleSettings.SetCollisions(collisionObjects);
m_clothParticleSystem = new ClothParticleSystem(particleSettings);
}
/// <summary>
/// Attempts to fill the calling <see cref="Board"/> instance with numbers.
/// The original instance remains unchanged
/// </summary>
/// <param name="Stream">If you already have a <see cref="Random"/> stream, you may provide it here</param>
/// <returns>Either a new instance of <see cref="Board"/> or, if unsuccessful, null</returns>
public Board Randomized(Random Stream)
{
var result = new Board(_parent);
ConstraintData data = new ConstraintData(result);
var digits = new List <int>();
for (int i = 1; i < 10; i++)
{
digits.Insert(Stream.Next(digits.Count), i);
}
if (RandomRecursion(result, data, digits, 0))
{
return(result);
}
return(null);
}
private List <ConstraintData> LoadConstraintData(string filename)
{
List <ConstraintData> data = new List <ConstraintData>();
string[] fields;
try
{
var reader = new StreamReader(File.OpenRead(filename));
while (!reader.EndOfStream)
{
ConstraintData tempConstraint = new ConstraintData();
fields = reader.ReadLine().Split(',');
tempConstraint.OrganName = fields[0];
tempConstraint.Bilateral = fields[1].Equals("1");
fields = reader.ReadLine().Split(',');
while (fields[0] != "end")
{
tempConstraint.ConstraintList.Add(fields[0]);
tempConstraint.ConstraintComparators.Add(fields[1]);
tempConstraint.ConstraintValues.Add(Convert.ToDouble(fields[2]));
tempConstraint.ConstraintUnits.Add(fields[3]);
tempConstraint.ConstraintComplications.Add(fields[4]);
fields = reader.ReadLine().Split(',');
}
data.Add(tempConstraint);
}
reader.Close();
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
return(data);
}
public Constraint( Expression expr, RelationalOperator op, double strength = Strength.reqq)
{
m_data= new ConstraintData(expr, op, strength);
}
private void UpdatePosition(bool forceUpdate = false)
{
if (SafeConstraint == null)
{
return;
}
if (!IsWorking && !forceUpdate)
{
return;
}
//if (!forceUpdate && !CubeGrid.SyncObject.ResponsibleForUpdate(Sync.Clients.LocalClient))
//return;
bool changed = false;
float compensatedDelta = Velocity / 60 * Sync.RelativeSimulationRatio;
ProfilerShort.Begin("PosAndHandlers");
if (!forceUpdate)
{
if (compensatedDelta < 0)
{
if (m_currentPos > MinLimit)
{
m_currentPos += compensatedDelta;
m_currentPos = Math.Max(m_currentPos, MinLimit);
changed = true;
if (m_currentPos == MinLimit)
{
var handle = LimitReached;
if (handle != null)
{
handle(false);
}
}
}
}
else if (m_currentPos < MaxLimit)
{
m_currentPos += compensatedDelta;
m_currentPos = Math.Min(m_currentPos, MaxLimit);
changed = true;
if (m_currentPos == MaxLimit)
{
var handle = LimitReached;
if (handle != null)
{
handle(true);
}
}
}
}
ProfilerShort.End();
if (changed || forceUpdate)
{
ProfilerShort.Begin("UpdateText");
UpdateText();
ProfilerShort.End();
ProfilerShort.Begin("UpdateAnimation");
UpdateAnimation();
ProfilerShort.End();
ProfilerShort.Begin("Calculations");
m_posChanged = true;
if (CubeGrid == null)
{
MySandboxGame.Log.WriteLine("CubeGrid is null");
}
if (m_topGrid == null)
{
MySandboxGame.Log.WriteLine("TopGrid is null");
}
if (Subpart3 == null)
{
MySandboxGame.Log.WriteLine("Subpart is null");
}
if (CubeGrid.Physics != null)
{
CubeGrid.Physics.RigidBody.Activate();
}
if (m_topGrid != null && m_topGrid.Physics != null)
{
m_topGrid.Physics.RigidBody.Activate();
}
var matAD = MatrixD.CreateWorld(Vector3D.Transform(Vector3D.Transform(m_constraintBasePos, Subpart3.WorldMatrix), CubeGrid.PositionComp.WorldMatrixNormalizedInv), PositionComp.LocalMatrix.Forward, PositionComp.LocalMatrix.Up);
var matA = (Matrix)matAD;
var matB = Matrix.CreateWorld(m_topBlock.Position * m_topBlock.CubeGrid.GridSize /*- m_topBlock.LocalMatrix.Up * m_currentPos*/, m_topBlock.PositionComp.LocalMatrix.Forward, m_topBlock.PositionComp.LocalMatrix.Up);
ProfilerShort.End();
ProfilerShort.Begin("SetInBodySpace");
ConstraintData.SetInBodySpace(ref matA, ref matB);
ProfilerShort.End();
ProfilerShort.Begin("UpdateSubpartFixedData");
UpdateSubpartFixedData();
ProfilerShort.End();
}
}
public Constraint( Constraint other, double strength)
{
m_data=new ConstraintData(other, strength);
}
//--------------------------------------------------------------------------------------------------
ConstraintData CreateConstraintData(SketchConstraint constraint, bool swapOrientation)
{
var data = new ConstraintData
{
Constraint = constraint,
Info = ""
};
if ((constraint.Points != null) && constraint.Points.Any())
{
data.Info += (constraint.Points.Length == 1 ? "Point " : "Points ") + string.Join(", ", constraint.Points);
if ((constraint.Segments != null) && constraint.Segments.Any())
{
data.Info += " ";
}
}
if ((constraint.Segments != null) && constraint.Segments.Any())
{
data.Info += (constraint.Segments.Length == 1 ? "Segment " : "Segments ") + string.Join(", ", constraint.Segments);
}
switch (constraint)
{
case SketchConstraintPerpendicular _:
data.Type = "Perpendicular";
break;
case SketchConstraintHorizontal _:
data.Type = swapOrientation ? "Vertical" : "Horizontal";
break;
case SketchConstraintVertical _:
data.Type = swapOrientation ? "Horizontal" : "Vertical";
break;
case SketchConstraintParallel _:
data.Type = "Parallel";
break;
case SketchConstraintConcentric _:
data.Type = "Concentric";
break;
case SketchConstraintPointOnSegment _:
data.Type = "Point on Segment";
break;
case SketchConstraintPointOnMidpoint _:
data.Type = "Point on Midpoint";
break;
case SketchConstraintFixed fixedConstraint:
switch (fixedConstraint.Target)
{
case SketchConstraintFixed.TargetType.Point:
data.Type = "Fix Point";
break;
case SketchConstraintFixed.TargetType.Segment:
data.Type = "Fix Segment";
break;
}
break;
case SketchConstraintEqual _:
data.Type = "Equal";
break;
case SketchConstraintAngle _:
data.Type = "Inner Angle";
data.ParameterName = "Angle";
data.Parameter = constraint.Parameter;
data.Units = ValueUnits.Degree;
break;
case SketchConstraintHorizontalDistance _:
data.Type = swapOrientation ? "Horiz. Distance" : "Vert. Distance";
data.ParameterName = "Distance";
data.Parameter = constraint.Parameter;
data.Units = ValueUnits.Length;
break;
case SketchConstraintVerticalDistance _:
data.Type = swapOrientation ? "Vert. Distance" : "Horiz. Distance";
data.ParameterName = "Distance";
data.Parameter = constraint.Parameter;
data.Units = ValueUnits.Length;
break;
case SketchConstraintLength _:
data.Type = "Length";
data.ParameterName = "Length";
data.Parameter = constraint.Parameter;
data.Units = ValueUnits.Length;
break;
case SketchConstraintRadius _:
data.Type = "Radius";
data.ParameterName = "Radius";
data.Parameter = constraint.Parameter;
data.Units = ValueUnits.Length;
break;
case SketchConstraintTangent _:
data.Type = "Tangent";
break;
default:
data.Type = "Unknown";
break;
}
return(data);
}
public override string ToString()
{
return(ConstraintData.ToString());
}
public Constraint() {
m_data=null;
}
