Esempio n. 1
0
 public VelocityPoint(double distance, double acceleration, double velocity, VelocityConstraint correspondingConstraint)
 {
     Distance                = distance;
     Acceleration            = acceleration;
     Velocity                = velocity;
     CorrespondingConstraint = correspondingConstraint;
 }
Esempio n. 2
0
        public void RelationalOperatorsWork()
        {
            // Arrange
            var con0 = new VelocityConstraint(0, 10, 100);
            var con1 = new VelocityConstraint(0, 10, 200);
            var con2 = new VelocityConstraint(0, 10, 200);

            // Act & Assert
            Assert.True(con0 < con1);
            Assert.False(con1 < con2);

            Assert.False(con1 <= con0);
            Assert.True(con1 <= con2);

            Assert.False(con0 > con1);
            Assert.False(con1 > con2);

            Assert.False(con0 >= con1);
            Assert.True(con1 >= con2);

            Assert.True(con0 < 150.0);
            Assert.True(con0 > 50.0);
            Assert.True(150.0 > con0);
            Assert.True(50.0 < con0);
        }
Esempio n. 3
0
 void Awake()
 {
     velocityLine       = new Line();
     velocityConstraint = new VelocityConstraint()
     {
         line = velocityLine
     };
     rbody = GetComponent <Rigidbody2D>();
 }
Esempio n. 4
0
        public void ReduceByWorks()
        {
            // Arrange
            var con = new VelocityConstraint(0, 10, 100);

            // Act
            con.ReduceBy(50);

            // Assert
            Assert.Equal(50.0, con.MaximumVelocity);
        }
Esempio n. 5
0
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("MJointConstraint");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         field.Name = "JointType";
         field.Type = TType.I32;
         field.ID   = 1;
         oprot.WriteFieldBegin(field);
         oprot.WriteI32((int)JointType);
         oprot.WriteFieldEnd();
         if (GeometryConstraint != null && __isset.GeometryConstraint)
         {
             field.Name = "GeometryConstraint";
             field.Type = TType.Struct;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             GeometryConstraint.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (VelocityConstraint != null && __isset.VelocityConstraint)
         {
             field.Name = "VelocityConstraint";
             field.Type = TType.Struct;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             VelocityConstraint.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (AccelerationConstraint != null && __isset.AccelerationConstraint)
         {
             field.Name = "AccelerationConstraint";
             field.Type = TType.Struct;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             AccelerationConstraint.Write(oprot);
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
Esempio n. 6
0
        public void ContainsWorks()
        {
            // Arrange
            var con = new VelocityConstraint(0, 100, 100);

            // Act
            var contains0 = con.Contains(0);
            var contains1 = con.Contains(50);
            var contains2 = con.Contains(100);

            // Assert
            Assert.True(contains0);
            Assert.True(contains1);
            Assert.False(contains2);
        }
Esempio n. 7
0
        public void CopyReturnsDeepCopy()
        {
            // Assert
            var con = new VelocityConstraint(0, 50, 100);

            // Act
            var conCopy = con.Copy();

            // Assert that copy has same values as original
            Assert.Equal(con.Start, conCopy.Start);
            Assert.Equal(con.Length, conCopy.Length);
            Assert.Equal(con.End, conCopy.End);
            Assert.Equal(con.MaximumVelocity, conCopy.MaximumVelocity);

            // Check that no references to original exist anymore
            conCopy.MaximumVelocity /= 2;

            Assert.Equal(100, con.MaximumVelocity);
            Assert.Equal(50, conCopy.MaximumVelocity);
        }
Esempio n. 8
0
        public void MathematicalOperatorsWork()
        {
            // Arrange
            var con0 = new VelocityConstraint(0, 10, 100);
            var con1 = new VelocityConstraint(0, 10, 200);
            var con2 = new VelocityConstraint(0, 10, 200);

            // Act
            var diff0 = con1 - con0;
            var diff1 = con2 - con1;
            var diff2 = con0 - con1;
            var diff3 = con0 - 50.0;
            var sum0  = con0 + 100.0;

            // Assert
            Assert.Equal(100.0, diff0);
            Assert.Equal(0.0, diff1);
            Assert.Equal(-100.0, diff2);
            Assert.Equal(50.0, diff3);
            Assert.Equal(200.0, sum0);
        }
Esempio n. 9
0
        public override string ToString()
        {
            StringBuilder __sb = new StringBuilder("MJointConstraint(");

            __sb.Append(", JointType: ");
            __sb.Append(JointType);
            if (GeometryConstraint != null && __isset.GeometryConstraint)
            {
                __sb.Append(", GeometryConstraint: ");
                __sb.Append(GeometryConstraint == null ? "<null>" : GeometryConstraint.ToString());
            }
            if (VelocityConstraint != null && __isset.VelocityConstraint)
            {
                __sb.Append(", VelocityConstraint: ");
                __sb.Append(VelocityConstraint == null ? "<null>" : VelocityConstraint.ToString());
            }
            if (AccelerationConstraint != null && __isset.AccelerationConstraint)
            {
                __sb.Append(", AccelerationConstraint: ");
                __sb.Append(AccelerationConstraint == null ? "<null>" : AccelerationConstraint.ToString());
            }
            __sb.Append(")");
            return(__sb.ToString());
        }
Esempio n. 10
0
 public VelocityPoint(double distance, double velocity, VelocityConstraint correspondingConstraint)
     : this(distance, 0.0, velocity, correspondingConstraint)
 {
 }
Esempio n. 11
0
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("MConstraint");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (ID == null)
         {
             throw new TProtocolException(TProtocolException.INVALID_DATA, "required field ID not set");
         }
         field.Name = "ID";
         field.Type = TType.String;
         field.ID   = 1;
         oprot.WriteFieldBegin(field);
         oprot.WriteString(ID);
         oprot.WriteFieldEnd();
         if (GeometryConstraint != null && __isset.GeometryConstraint)
         {
             field.Name = "GeometryConstraint";
             field.Type = TType.Struct;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             GeometryConstraint.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (VelocityConstraint != null && __isset.VelocityConstraint)
         {
             field.Name = "VelocityConstraint";
             field.Type = TType.Struct;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             VelocityConstraint.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (AccelerationConstraint != null && __isset.AccelerationConstraint)
         {
             field.Name = "AccelerationConstraint";
             field.Type = TType.Struct;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             AccelerationConstraint.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (PathConstraint != null && __isset.PathConstraint)
         {
             field.Name = "PathConstraint";
             field.Type = TType.Struct;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             PathConstraint.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (JointPathConstraint != null && __isset.JointPathConstraint)
         {
             field.Name = "JointPathConstraint";
             field.Type = TType.Struct;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             JointPathConstraint.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (PostureConstraint != null && __isset.PostureConstraint)
         {
             field.Name = "PostureConstraint";
             field.Type = TType.Struct;
             field.ID   = 7;
             oprot.WriteFieldBegin(field);
             PostureConstraint.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (JointConstraint != null && __isset.JointConstraint)
         {
             field.Name = "JointConstraint";
             field.Type = TType.Struct;
             field.ID   = 8;
             oprot.WriteFieldBegin(field);
             JointConstraint.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (Properties != null && __isset.Properties)
         {
             field.Name = "Properties";
             field.Type = TType.Map;
             field.ID   = 9;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteMapBegin(new TMap(TType.String, TType.String, Properties.Count));
                 foreach (string _iter4 in Properties.Keys)
                 {
                     oprot.WriteString(_iter4);
                     oprot.WriteString(Properties[_iter4]);
                 }
                 oprot.WriteMapEnd();
             }
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }