#pragma warning disable 0219
public static void Test()
{
ViAngle angle0 = new ViAngle(ViMathDefine.PI * 0.5f);
ViAngle angle1 = new ViAngle(-ViMathDefine.PI);
float fDiff = ViAngle.Diff(angle0, angle1); //-pi/ 2
float fSameSignAngle = ViAngle.SameSignAngle(angle0, angle1); //- 1.5pi
bool bIsIn = angle1.IsBetween(angle1, angle0); //true
ViAngle angle2 = new ViAngle(8.0f);
ViAngle angle3 = new ViAngle(12.0f);
float fDiff1 = ViAngle.Diff(angle2, angle3);
float fSameSignAngle1 = ViAngle.SameSignAngle(angle2, angle3);
bool bIsIn1 = angle1.IsBetween(angle2, angle3);
ViAngle angle4 = new ViAngle(3.0f);
ViAngle angle5 = new ViAngle(-3.0f);
ViAngle angle6 = new ViAngle(-3.1f);
ViAngle angle7 = new ViAngle(1.0f);
bool bIsIn2 = angle6.IsBetween(angle4, angle5);
ViDebuger.AssertError(bIsIn2 == true);
bool bIsIn3 = angle6.IsBetween(angle5, angle4);
ViDebuger.AssertError(bIsIn3 == false);
bool bIsIn4 = angle7.IsBetween(angle4, angle5);
ViDebuger.AssertError(bIsIn4 == false);
bool bIsIn5 = angle7.IsBetween(angle5, angle4);
ViDebuger.AssertError(bIsIn5 == true);
}
public bool Tick(float fDeltaTime)
{
if (_destDirectionProvider == null)
{
return(false);
}
bool result = false;
float yaw = _destDirectionProvider.Value.Value;
float feetDirection = _feetDirection;
float oldCursorYaw = _cursorYaw;
_cursorYaw = yaw - feetDirection;
ViAngle.Normalize(ref _cursorYaw);
Int32 fomated = _FomatByMaxAngle(ref feetDirection, yaw);
if (oldCursorYaw != _cursorYaw)
{
OnRoteUpdated();
}
if (fomated != 0)
{
if (_accordSign == 0)
{
_accordSign = fomated;
OnRoteStart();
}
result = true;
}
if (_accordSign != 0)
{
float frameDeltaYaw = _accordSpd * fDeltaTime;
if (_cursorYaw > frameDeltaYaw)
{
feetDirection += frameDeltaYaw;
ViAngle.Normalize(ref feetDirection);
result = true;
}
else if (_cursorYaw < -frameDeltaYaw)
{
feetDirection -= frameDeltaYaw;
ViAngle.Normalize(ref feetDirection);
result = true;
}
else
{
feetDirection = yaw;
OnRoteEnd();
_accordSign = 0;
}
}
_feetDirection = feetDirection;
_bodyDirection = (feetDirection + yaw) * 0.5f;
return(result);
}
public float GetAngleFromDirection(float deltaX, float deltaY)
{
if (Math.Abs(deltaX) < 0.1f && Math.Abs(deltaY) < 0.1f)
{
return(0.0f);
}
float deltaAngle = GetDirection(deltaX, deltaY) - Yaw;
ViAngle.Normalize(ref deltaAngle);
return(deltaAngle);
}
public bool IsBetween(ViAngle kLeft, ViAngle kRight)
{
if (kLeft.Value <= kRight.Value)
{
return(kLeft.Value <= Value && Value <= kRight.Value);
}
else
{
return(kLeft.Value <= Value || Value <= kRight.Value);
}
}
public void Init(float radius, float leftAngle, float rightAngle)
{
_leftAngle = leftAngle;
ViAngle.Normalize(ref _leftAngle);
_rightAngle = rightAngle;
ViAngle.Normalize(ref _rightAngle);
if (_leftAngle > _rightAngle)
{
_rightAngle += ViMathDefine.PI_X2;
}
_range = radius;
_radius2 = radius * radius;
ViDebuger.AssertWarning(_leftAngle <= _rightAngle);
}
public static float SameSignAngle(ViAngle angle, ViAngle record)
{
if (angle.Value > record.Value + ViMathDefine.PI)
{
return(angle.Value - ViMathDefine.PI_X2);
}
else if (angle.Value < record.Value - ViMathDefine.PI)
{
return(angle.Value + ViMathDefine.PI_X2);
}
else
{
return(angle.Value);
}
}
public static float Diff(ViAngle from, ViAngle to)
{
float fDiff = from.Value - to.Value;
if (fDiff < -ViMathDefine.PI)
{
return(fDiff + ViMathDefine.PI_X2);
}
else if (fDiff >= ViMathDefine.PI)
{
return(fDiff - ViMathDefine.PI_X2);
}
else
{
return(fDiff);
}
}
Int32 _FomatByMaxAngle(ref float feetDirection, float bodyYaw)
{
if (_cursorYaw > _allowAngle)
{
feetDirection = bodyYaw - _allowAngle;
_cursorYaw = _allowAngle;
ViAngle.Normalize(ref feetDirection);
return(1);
}
else if (_cursorYaw < -_allowAngle)
{
feetDirection = bodyYaw + _allowAngle;
_cursorYaw = -_allowAngle;
ViAngle.Normalize(ref feetDirection);
return(-1);
}
return(0);
}
public bool Update(float deltaTime, float newDir)
{
if (newDir == _curDiretion)
{
return(false);
}
float maxRot = deltaTime * _rotSpd;
float deltaAngle = newDir - _curDiretion;
ViAngle.Normalize(ref deltaAngle);
if (Math.Abs(deltaAngle) < maxRot)
{
_curDiretion = newDir;
}
else
{
_curDiretion += maxRot * ViMathDefine.Sign(deltaAngle);
}
ViAngle.Normalize(ref _curDiretion);
return(true);
}
public bool Update(float deltaTime, float newDir)
{
float deltaAngle = newDir - _curDiretion;
if (deltaAngle == 0.0f)
{
return(false);
}
ViAngle.Normalize(ref deltaAngle);
float maxRot = 0.0f;
if (deltaAngle > 0.0f)
{
_currentSpeed = Math.Abs(_currentSpeed);
float newSpd = _currentSpeed + _accelerate * deltaTime;
float maxSpd = ViMathDefine.Sqrt(deltaAngle * _accelerate * 2.0f);
_currentSpeed = ViMathDefine.Min(ViMathDefine.Min(newSpd, maxSpd), _maxSpeed);
maxRot = _currentSpeed * deltaTime;
}
else
{
_currentSpeed = -Math.Abs(_currentSpeed);
float newSpd = _currentSpeed - _accelerate * deltaTime;
float maxSpd = -ViMathDefine.Sqrt(-deltaAngle * _accelerate * 2.0f);
_currentSpeed = ViMathDefine.Max(ViMathDefine.Max(newSpd, maxSpd), -_maxSpeed);
maxRot = _currentSpeed * deltaTime;
}
if (Math.Abs(deltaAngle) < Math.Abs(maxRot))
{
_curDiretion = newDir;
_currentSpeed = 0.0f;
}
else
{
_curDiretion += maxRot;
}
ViAngle.Normalize(ref _curDiretion);
return(true);
}
public ViAngle(ViAngle rAngle)
{
_value = rAngle.Value;
}
public void Lerp(ViAngle a, ViAngle b, float t)
{
_value = a.Value * t + SameSignAngle(a, b) * (1 - t);
Normalize();
}
