private static IPoint CreateErrorPoint([NotNull] AngleInfo angleInfo)
{
IPoint result = new PointClass();
result.PutCoords(angleInfo.X, angleInfo.Y);
result.Z = angleInfo.Z;
return(result);
}
public void groundedMovement(float speedX)
{
//Check velocity depending on angle
if (speedX > 0)
{
if (rightTopAnglePos && canBumpTop)
{
rightTopAngle = RayCastSide(rightTopAnglePos, 1f);
if (rightTopAngle.detect)
{
isBumping = true;
return;
}
}
if (Mathf.Abs(rightAngle.angle) > maxStandingAngle && rightAngle.angle < 0 && canBumpRight)
{
return;
}
Vector3 tempDirection = new Vector3((rightAngle.normal.y != 0) ? rightAngle.normal.y : 1, -rightAngle.normal.x, 0);
//Debug.Log("temp direction: " + tempDirection);
transform.Translate(tempDirection * speedX * Time.deltaTime);
}
if (speedX < 0)
{
if (leftTopAnglePos && canBumpTop)
{
leftTopAngle = RayCastSide(leftTopAnglePos, -1f);
if (leftTopAngle.detect)
{
isBumping = true;
return;
}
}
if (Mathf.Abs(leftAngle.angle) > maxStandingAngle && leftAngle.angle > 0 && canBumpLeft)
{
return;
}
Vector3 tempDirection = new Vector3((leftAngle.normal.y != 0) ? leftAngle.normal.y : 1, -leftAngle.normal.x, 0);
//Debug.Log("temp direction: " + tempDirection);
transform.Translate(tempDirection * speedX * Time.deltaTime);
}
stickToFloor();
}
public override IEnumerable <AngleInfo> GetAngles()
{
ISegment pre = null;
if (((ICurve)_segments).IsClosed)
{
pre = GetLastNonZeroLengthSegment(_segments);
}
IEnumSegment enumSegments = _segments.EnumSegments;
bool recycling = enumSegments.IsRecycling;
ISegment segment;
var partIndex = 0;
var segmentIndex = 0;
enumSegments.Next(out segment, ref partIndex, ref segmentIndex);
while (segment != null)
{
// ignore zero-length segments
if (!IsZeroLength(segment))
{
ISegment next = recycling
? GeometryFactory.Clone(segment)
: segment;
if (pre != null)
{
yield return(AngleInfo.Create(pre, next, Settings.Is3D));
}
pre = next;
}
if (recycling)
{
// release the segment, otherwise "pure virtual function call" occurs
// when there are certain circular arcs (IsLine == true ?)
Marshal.ReleaseComObject(segment);
}
enumSegments.Next(out segment, ref partIndex, ref segmentIndex);
}
}
public void AngleCalculation()
{
canBump = true;
canBumpLeft = true;
canBumpRight = true;
//Check all angles
leftAngle.reset();
middleAngle.reset();
rightAngle.reset();
middleAngle = RayCastDown(middleAnglePos);
topAngle = RayCastUp(topAnglePos);
leftAngle = RayCastSide(leftAnglePos, -1f);
if (!leftAngle.detect)
{
leftAngle = RayCastDown(leftAnglePos);
}
if (!leftAngle.detect)
{
leftAngle = RayCastSide(leftAnglePos, 1.5f, -raycastDistance);
canBumpLeft = false;
}
rightAngle = RayCastSide(rightAnglePos, 1f);
if (!rightAngle.detect)
{
rightAngle = RayCastDown(rightAnglePos);
}
if (!rightAngle.detect)
{
rightAngle = RayCastSide(rightAnglePos, -1.5f, -raycastDistance);
canBumpRight = false;
}
//Debug.Log("left: " + leftAngle.angle + "middle: " + middleAngle.angle + "right: " + rightAngle.angle);
}
// Update is called once per frame
void Update()
{
//Check all angles
leftAngle.reset();
middleAngle.reset();
rightAngle.reset();
middleAngle = RayCastDown(middleAnglePos, true);
//Check front, downwards and inwards for left and right angles
leftAngle = RayCastSide(leftAnglePos, -1f);
if (!leftAngle.detect)
{
leftAngle = RayCastDown(leftAnglePos);
}
rightAngle = RayCastSide(rightAnglePos, 1f);
if (!rightAngle.detect)
{
rightAngle = RayCastDown(rightAnglePos);
}
if (!stick)
{
Debug.Log("not sticking");
transform.eulerAngles = new Vector3(0, 0, 0);
}
gravityCheck();
crouchSlope();
Debug.Log("left: " + leftAngle.angle + "middle: " + middleAngle.angle + "right: " + rightAngle.angle);
MoveSideWays(velocityX);
skatingTiming();
}
public IList <AngleInfo> ConvertAnglesToAngleInfos(IEnumerable <double> anglesInDegrees)
{
List <double> anglesList = new List <double>();
List <AngleInfo> angleInfosList = new List <AngleInfo>();
//Use the "ToList" extension method to convert an IEnumerable to a List
anglesList = anglesInDegrees.ToList();
//Define the query expression
var convertedAnglesQuery = from angle in anglesList
select angle;
//Execute the query
foreach (var angle in convertedAnglesQuery) //triggers query execution
{
AngleInfo hoek = new AngleInfo();
hoek.Angle = angle;
hoek.Cosinus = Math.Cos(angle * Math.PI / 180);
hoek.Sinus = Math.Sin(angle * Math.PI / 180);
angleInfosList.Add(hoek);
}
return(angleInfosList);
}
public override IEnumerable <AngleInfo> GetAngles()
{
int partIndex;
int vertexIndex;
double x2 = 0;
double y2 = 0;
double z2 = 0;
double dx1 = 0;
double dy1 = 0;
double dz1 = 0;
double l12 = 0;
var minVertex = 2;
if (((ICurve)_points).IsClosed)
{
var segments = _points as ISegmentCollection;
if (segments != null)
{
int segmentCount = segments.SegmentCount;
if (segmentCount == 1)
{
ISegment segment = segments.Segment[0];
if (IsZeroLength(segment))
{
// single zero-length segment forming a closed curve, ignore
// NOTE: closed elliptic arcs also report length = 0, unable to calculate tangents --> ignored here
yield break;
}
AngleInfo info = AngleInfo.Create(segment, segment, Settings.Is3D);
yield return(info);
yield break;
}
if (segmentCount == 2)
{
ISegment segment0 = segments.Segment[0];
ISegment segment1 = segments.Segment[1];
if (!(segment0 is ILine) || !(segment1 is ILine))
{
// two segment closed curve, at least one of the segments is non-linear
// --> calculate using tangent
// otherwise, linearized segment angles would always be 0, resulting in errors
bool segment0IsZeroLength = IsZeroLength(segment0);
bool segment1IsZeroLength = IsZeroLength(segment1);
if (!segment0IsZeroLength && !segment1IsZeroLength)
{
yield return
(AngleInfo.Create(segment0, segment1, Settings.Is3D));
yield return
(AngleInfo.Create(segment1, segment0, Settings.Is3D));
}
else if (segment0IsZeroLength)
{
yield return
(AngleInfo.Create(segment1, segment1, Settings.Is3D));
}
else
{
// segment 1 is zero length
yield return
(AngleInfo.Create(segment0, segment0, Settings.Is3D));
}
yield break;
}
}
}
_points.QueryPoint(_points.PointCount - 2, Settings.QueryPoint);
Settings.QueryPoint.QueryCoords(out x2, out y2);
z2 = Settings.QueryPoint.Z;
minVertex = 1;
}
IEnumVertex vertexEnum = _points.EnumVertices;
vertexEnum.QueryNext(Settings.QueryPoint, out partIndex, out vertexIndex);
while (partIndex >= 0 && vertexIndex >= 0)
{
double dx0 = dx1;
double dy0 = dy1;
double l02 = l12;
double x1 = x2;
double y1 = y2;
double z1 = z2;
Settings.QueryPoint.QueryCoords(out x2, out y2);
z2 = Settings.QueryPoint.Z;
dx1 = x2 - x1;
dy1 = y2 - y1;
l12 = dx1 * dx1 + dy1 * dy1;
double prod = dx0 * dx1 + dy0 * dy1;
if (Settings.Is3D)
{
double dz0 = dz1;
dz1 = z2 - z1;
l12 += dz1 * dz1;
prod += dz0 * dz1;
}
if (vertexIndex < minVertex)
{
vertexEnum.QueryNext(Settings.QueryPoint, out partIndex, out vertexIndex);
continue;
}
var angleInfo = new AngleInfo(x1, y1, z1, l02, l12, prod);
yield return(angleInfo);
vertexEnum.QueryNext(Settings.QueryPoint, out partIndex, out vertexIndex);
}
}
private AngleWin32EglDisplay(EglInterface egl, AngleInfo info) : base(egl, info.Display)
{
PlatformApi = info.PlatformApi;
}
