/// <summary>
/// Special overload for handoffs
/// </summary>
/// <param name="warpingObject"></param>
/// <param name="oldSystemModel"></param>
public void SetEntryPositionFromSystem(IHasPosition warpingObject)
{
//Flip to opposite side to match entry warphole position
warpingObject.PosX *= -1;
warpingObject.PosY *= -1;
warpingObject.SetRandomPointInRadius(.75f, 1.5f);
}
public float GetDistanceSq(IHasPosition pos)
{
var dx = (pos.Position.X - Position.X);
var dy = (pos.Position.Y - Position.Y);
var dz = (pos.Position.Z - Position.Z);
return((dx * dx) + (dy * dy) + (dz * dz));
}
/// <summary>
/// Sets position a point in a disk defined by innerRadius and outerRadius radii and centered on obj's current position.
/// </summary>
public static void SetRandomPointInRadius(this IHasPosition obj, float innerRadius, float outerRadius)
{
float length = innerRadius + (outerRadius - innerRadius) * (float)Rand.Random.NextDouble();
float angle = (float)(2 * Math.PI * Rand.Random.NextDouble());
obj.PosX += length * (float)Math.Cos(angle);
obj.PosY += length * (float)Math.Sin(angle);
}
/// <summary>
/// Moves this Unit to the given position and then assumes arrivedState
/// </summary>
/// <param name="pos"></param>
/// <param name="arrivedState">The BrainState to enter once arrived</param>
/// <remarks>Requires Brain</remarks>
public void MoveToThenEnter(IHasPosition pos, bool findPath, BrainState arrivedState)
{
if (CheckBrain())
{
//m_brain.StopCurrentAction();
m_Movement.MoveTo(pos.Position, findPath);
m_brain.CurrentAction = new AIMoveThenEnterAction(this, arrivedState);
}
}
public override void SetEntryPosition(IHasPosition warpingObject, IArea oldArea)
{
//TODO: Replace with starport style safe zone
float xpos = Warpholes[0].PosX;
float ypos = Warpholes[0].PosY;
SpatialOperations.GetRandomPointInRadius(ref xpos, ref ypos, .5f, 3);
warpingObject.PosX = xpos;
warpingObject.PosY = ypos;
}
/// <summary>
/// Gets the angle between this object and the given position, in relation to the north-south axis
/// </summary>
public float GetAngleTowards(IHasPosition obj)
{
var angle = (float)Math.Atan2((obj.Position.Y - m_position.Y), (obj.Position.X - m_position.X));
if (angle < 0)
{
// wrap angle from 0 to 2*PI (instead of -PI to PI) to correspond with orientation
angle += (2 * MathUtil.PI);
}
return(angle);
}
/// <summary>
/// this method does not in use
/// </summary>
/// <param name="original"></param>
/// <param name="beatmap"></param>
/// <returns></returns>
protected override IEnumerable <BaseRpObject> ConvertHitObject(HitObject original, Beatmap beatmap)
{
IHasCurve curveData = original as IHasCurve;
IHasEndTime endTimeData = original as IHasEndTime;
IHasPosition positionData = original as IHasPosition;
IHasCombo comboData = original as IHasCombo;
/*
* if (curveData != null)
* {
* yield return new RpSlider
* {
* StartTime = original.StartTime,
* Samples = original.Samples,
* CurveObject = curveData,
* Position = positionData?.Position ?? Vector2.Zero,
* NewCombo = comboData?.NewCombo ?? false
* };
* }
* else if (endTimeData != null)
* {
* yield return new Spinner
* {
* StartTime = original.StartTime,
* Samples = original.Samples,
* EndTime = endTimeData.EndTime,
*
* Position = positionData?.Position ?? OsuPlayfield.BASE_SIZE / 2,
* };
* }
* else
* {
* yield return new HitCircle
* {
* StartTime = original.StartTime,
* Samples = original.Samples,
* Position = positionData?.Position ?? Vector2.Zero,
* NewCombo = comboData?.NewCombo ?? false
* };
* }
*/
yield return((BaseRpObject)original);
}
private OsuHitObject convertHitObject(HitObject original)
{
IHasCurve curveData = original as IHasCurve;
IHasEndTime endTimeData = original as IHasEndTime;
IHasPosition positionData = original as IHasPosition;
IHasCombo comboData = original as IHasCombo;
if (curveData != null)
{
return(new Slider
{
StartTime = original.StartTime,
Sample = original.Sample,
CurveObject = curveData,
Position = positionData?.Position ?? Vector2.Zero,
NewCombo = comboData?.NewCombo ?? false
});
}
if (endTimeData != null)
{
return(new Spinner
{
StartTime = original.StartTime,
Sample = original.Sample,
Position = new Vector2(512, 384) / 2,
EndTime = endTimeData.EndTime
});
}
return(new HitCircle
{
StartTime = original.StartTime,
Sample = original.Sample,
Position = positionData?.Position ?? Vector2.Zero,
NewCombo = comboData?.NewCombo ?? false
});
}
public override void SetEntryPosition(IHasPosition warpingObject, IArea oldArea)
{
if (oldArea == null)
{
warpingObject.PosX = 0;
warpingObject.PosY = 0;
warpingObject.SetRandomPointInRadius(Star.Radius + .1f, Star.Radius + 1f);
}
else
{
switch (oldArea.AreaType)
{
case AreaTypes.System:
{
SetEntryPositionFromSystem(warpingObject);
break;
}
case AreaTypes.Planet:
case AreaTypes.Port:
case AreaTypes.StarBase:
{
warpingObject.PosX = oldArea.PosX;
warpingObject.PosY = oldArea.PosY;
warpingObject.SetRandomPointInRadius(oldArea.AreaSize / 100f + .1f, oldArea.AreaSize / 100f + 1.5f);
break;
}
case AreaTypes.Colony:
{
var pa = oldArea.GetParentArea();
float parentPosX = pa.PosX;
float parentPosY = pa.PosY;
SpatialOperations.GetRandomPointInRadius(ref parentPosX, ref parentPosY, pa.AreaSize / 100f + .1f, pa.AreaSize / 100f + 1.5f);
warpingObject.PosX = parentPosX;
warpingObject.PosY = parentPosY;
break;
}
}
}
}
public static float GetDistance(this IHasPosition s, IHasPosition c)
{
return((float)Math.Sqrt((s.PosX * -c.PosX) + (s.PosY - c.PosY)));
}
public ParticlePhysics2(IHasPosition<float> position)
{
pos = position;
}
/// <summary>
/// Moves this Unit to the given position and then assumes arrivedState
/// </summary>
/// <param name="pos"></param>
/// <param name="arrivedState">The BrainState to enter once arrived</param>
/// <remarks>Requires Brain</remarks>
public void MoveToThenEnter(IHasPosition pos, bool findPath, BrainState arrivedState)
{
if (CheckBrain())
{
//m_brain.StopCurrentAction();
m_Movement.MoveTo(pos.Position, findPath);
m_brain.CurrentAction = new AIMoveThenEnterAction(this, arrivedState);
}
}
public void SetOrientationTowards(IHasPosition pos)
{
m_orientation = GetAngleTowards(pos);
}
public static float GetDist(this IHasPosition pos, IHasPosition pos2)
{
return(pos.Position.GetDistance(pos2.Position));
}
/// <summary>
/// Gets the angle between this object and the given position, in relation to the north-south axis
/// </summary>
public float GetAngleTowards(IHasPosition obj)
{
var angle = (float)Math.Atan2((obj.Position.Y - m_position.Y), (obj.Position.X - m_position.X));
if (angle < 0)
{
// wrap angle from 0 to 2*PI (instead of -PI to PI) to correspond with orientation
angle += (2 * MathUtil.PI);
}
return angle;
}
public bool IsInRadiusSq(IHasPosition pos, float sqDistance)
{
return GetDistanceSq(pos) <= sqDistance;
}
public ArrivingSteering(Kinematic character, IHasPosition target, float maxAcceleration, float slowRadius, float satisfactionRadius)
: base(character, target, maxAcceleration)
{
mSatisfactionRadius = satisfactionRadius;
mSlowRadius = slowRadius;
}
public virtual void SetEntryPosition(IHasPosition warpingObject, IArea oldArea)
{
}
bool CheckDistance(IHasPosition obj1, IHasPosition obj2, float tolerance)
{
return(Math.Sqrt(Math.Pow(obj1.PosX - obj2.PosX, 2) + Math.Pow(obj1.PosY - obj2.PosY, 2)) <= tolerance);
}
// Pseudo "range check" private static bool IsInRange(IHasPosition a, IHasPosition b) => a.Position.Zone == b.Position.Zone;
private void addCurveData(TextWriter writer, IHasCurve curveData, IHasPosition positionData)
{
PathType?lastType = null;
for (int i = 0; i < curveData.Path.ControlPoints.Count; i++)
{
PathControlPoint point = curveData.Path.ControlPoints[i];
if (point.Type.Value != null)
{
if (point.Type.Value != lastType)
{
switch (point.Type.Value)
{
case PathType.Bezier:
writer.Write("B|");
break;
case PathType.Catmull:
writer.Write("C|");
break;
case PathType.PerfectCurve:
writer.Write("P|");
break;
case PathType.Linear:
writer.Write("L|");
break;
}
lastType = point.Type.Value;
}
else
{
// New segment with the same type - duplicate the control point
writer.Write(FormattableString.Invariant($"{positionData.X + point.Position.Value.X}:{positionData.Y + point.Position.Value.Y}|"));
}
}
if (i != 0)
{
writer.Write(FormattableString.Invariant($"{positionData.X + point.Position.Value.X}:{positionData.Y + point.Position.Value.Y}"));
writer.Write(i != curveData.Path.ControlPoints.Count - 1 ? "|" : ",");
}
}
writer.Write(FormattableString.Invariant($"{curveData.RepeatCount + 1},"));
writer.Write(FormattableString.Invariant($"{curveData.Path.Distance},"));
for (int i = 0; i < curveData.NodeSamples.Count; i++)
{
writer.Write(FormattableString.Invariant($"{(int)toLegacyHitSoundType(curveData.NodeSamples[i])}"));
writer.Write(i != curveData.NodeSamples.Count - 1 ? "|" : ",");
}
for (int i = 0; i < curveData.NodeSamples.Count; i++)
{
writer.Write(getSampleBank(curveData.NodeSamples[i], true));
writer.Write(i != curveData.NodeSamples.Count - 1 ? "|" : ",");
}
}
public RefugeeSteering(Kinematic character, IHasPosition target, float maxAcceleration)
: base(character, target, maxAcceleration)
{
}
public void SetOrientationTowards(IHasPosition pos)
{
m_orientation = GetAngleTowards(pos);
}
/// <summary>
/// Moves this Unit to the given position and then assumes arrivedState
/// </summary>
/// <param name="pos"></param>
/// <param name="arrivedState">The BrainState to enter once arrived</param>
/// <remarks>Requires Brain</remarks>
public void MoveToThenEnter(IHasPosition pos, BrainState arrivedState)
{
MoveToThenEnter(pos, true, arrivedState);
}
public float GetDistanceSq(IHasPosition pos)
{
var dx = (pos.Position.X - Position.X);
var dy = (pos.Position.Y - Position.Y);
var dz = (pos.Position.Z - Position.Z);
return (dx * dx) + (dy * dy) + (dz * dz);
}
public static bool IsNear(this IHasPosition first, IHasPosition second)
{
return(Vector3.Distance(first.Position, second.Position) < 2.0f);
}
protected SteeringBase(Kinematic character, IHasPosition target, float maxAcceleration)
{
Character = character;
Target = target;
MaxAcceleration = maxAcceleration;
}
/// <summary>
/// Moves this Unit to the given position and then assumes arrivedState
/// </summary>
/// <param name="pos"></param>
/// <param name="arrivedState">The BrainState to enter once arrived</param>
/// <remarks>Requires Brain</remarks>
public void MoveToThenEnter(IHasPosition pos, BrainState arrivedState)
{
MoveToThenEnter(pos, true, arrivedState);
}
public static float GetDistSq(this IHasPosition pos, Vector3 pos2)
{
return(pos.Position.DistanceSquared(pos2));
}
public bool IsInRadiusSq(IHasPosition pos, float sqDistance)
{
return(GetDistanceSq(pos) <= sqDistance);
}
/// <summary>
/// Moves this Unit to the given position and then goes Idle
/// </summary>
/// <param name="pos"></param>
/// <remarks>Requires Brain</remarks>
public void MoveToThenIdle(IHasPosition pos)
{
MoveToThenEnter(pos, BrainState.Idle);
}
public static float DistanceTo(this IHasPosition s1, IHasPosition s2)
{
return((float)Math.Sqrt(Math.Pow(s1.PosX - s2.PosX, 2) + Math.Pow(s1.PosY - s2.PosY, 2)));
}
/// <summary>
/// Moves this Unit to the given position and then goes Idle
/// </summary>
/// <param name="pos"></param>
/// <remarks>Requires Brain</remarks>
public void MoveToThenIdle(IHasPosition pos)
{
MoveToThenEnter(pos, BrainState.Idle);
}
public ParticlePhysics2(IHasPosition<float> position) {
pos = position;
}
