public DirectionalWithoutRollManeuver(ManeuverType maneuverType, int startTick, Euler3 direction, MovementOptions movementOptions) { base.ManeuverType = maneuverType; this.startTick = new Tick(startTick); this.direction = direction; options = movementOptions; }
public static Quaternion RotateOverTimeFromReferenceFrame(Quaternion rotateThis, Quaternion byThis, Quaternion asIfMeasuredFromThis, float dt) { Quaternion start = Quaternion.Inverse(asIfMeasuredFromThis) * rotateThis; Quaternion rhs = Euler3.RotateOverTime(start, byThis, dt); return(asIfMeasuredFromThis * rhs); }
private void BuildFrame(Tick tick, out MovementFrame frame) { frame = MovementFrame.Invalid; Stack <Maneuver> stack = GetManeuvers(tick); if (stack == null) { frame.valid = false; return; } Maneuver maneuver = stack.Pop(); MovementFrame frame2 = GetTickFrame(tick - 1); if (!frame2.valid && tick > oldTick) { BuildFrame(tick - 1, out frame2); } frame2.valid = true; frame = maneuver.NextFrame(tick, frame2); Vector3 position = frame.position; Euler3 euler = frame.euler3; foreach (Maneuver item in stack) { frame = item.NextFrame(tick, frame); } frame.position = position; frame.euler3 = euler; }
public void Read(ManeuverType maneuverType, int startTick, Vector3 position, Euler3 euler3) { base.ManeuverType = maneuverType; this.startTick = new Tick(startTick); this.position = position; this.euler3 = euler3; }
public static Euler3 RotateOverTime(Euler3 start, Euler3 changePerSecond, float dt) { Vector3 vector = changePerSecond.ComponentsToVector3(); Quaternion lhs = Quaternion.AngleAxis(vector.magnitude * dt, vector.normalized); return(Rotation(lhs * start.rotation)); }
public void Read(ManeuverType maneuverType, int startTick, Euler3 direction, MovementOptions movementOptions) { base.ManeuverType = maneuverType; this.startTick = new Tick(startTick); this.direction = direction; options = movementOptions; }
protected MovementFrame MoveToDirection(MovementFrame prevFrame, Euler3 direction) { if (!prevFrame.valid) { return(MovementFrame.Invalid); } return(Simulation.MoveToDirection(prevFrame, direction, options)); }
public MovementFrame(Vector3 position, Euler3 euler3, Vector3 linearSpeed, Vector3 strafeSpeed, Euler3 euler3Speed) { this.position = position; this.euler3 = euler3; this.linearSpeed = linearSpeed; this.strafeSpeed = strafeSpeed; Euler3Speed = euler3Speed; mode = 0; valid = true; }
public Quaternion GetFutureRotation(float t) { if (mode == 2) { return(Euler3.RotateOverTime(euler3, Euler3Speed, t).rotation); } if (mode == 3) { return(Euler3.RotateOverTimeLocal(euler3, Euler3Speed, t).rotation); } return((euler3 + Euler3Speed * t).rotation); }
public static MovementFrame MoveToDirection(MovementFrame prevFrame, Euler3 targetEuler3, MovementOptions options) { Euler3 euler = prevFrame.euler3; Euler3 to = options.MaxEulerSpeed(euler); Euler3 from = options.MinEulerSpeed(euler); Euler3 euler2 = (targetEuler3 - euler).Normalized(false); float num = Mathf.Abs(2f * euler2.pitch / options.pitchAcceleration); float num2 = Mathf.Abs(2f * euler2.yaw / options.yawAcceleration); float num3 = 0f; if (euler2.yaw > Mathf.Epsilon) { num3 = options.yawAcceleration * num2; } else if (euler2.yaw < 0f - Mathf.Epsilon) { num3 = (0f - options.yawAcceleration) * num2; } float num4 = 0f; if (euler2.pitch > Mathf.Epsilon) { num4 = options.pitchAcceleration * num; } else if (euler2.pitch < 0f - Mathf.Epsilon) { num4 = (0f - options.pitchAcceleration) * num; } Euler3 zero = Euler3.zero; zero.yaw = (num3 - prevFrame.Euler3Speed.yaw) / 0.1f; zero.pitch = (num4 - prevFrame.Euler3Speed.pitch) / 0.1f; float num5 = Mathf.Clamp((0f - euler2.yaw) * options.maxRoll / 135f, 0f - options.maxRoll, options.maxRoll); float num6 = Algorithm3D.NormalizeAngle(num5 - euler.roll); zero.roll = options.rollAcceleration * (num6 / options.maxRoll - prevFrame.Euler3Speed.roll * options.rollFading / options.rollMaxSpeed); zero.Clamp(-options.maxTurnAcceleration, options.maxTurnAcceleration); Euler3 euler3Speed = prevFrame.Euler3Speed + zero * 0.1f; euler3Speed.Clamp(from, to); Vector3 linearSpeed = AdvanceLinearSpeed(prevFrame, options); Vector3 strafeSpeed = AdvanceStrafingSpeed(prevFrame, options, 0f, 0f); Euler3 nextEuler = prevFrame.NextEuler3; MovementFrame result = new MovementFrame(prevFrame.nextPosition, nextEuler, linearSpeed, strafeSpeed, euler3Speed); Quaternion rotationDelta = nextEuler.rotation * Quaternion.Inverse(prevFrame.rotation) * Quaternion.identity; //result.ActiveThrusterEffects = DetermineThrusterEffects(rotationDelta, 0f, 0f); result.mode = 0; return(result); }
public static MovementFrame QWEASD(MovementFrame prevFrame, float pitch, float yaw, float roll, MovementOptions options) { Vector3 vector = new Vector3(pitch, yaw, roll); Vector3 b = (options.maxTurnAcceleration * 0.1f).ComponentsToVector3(); vector = Vector3.Scale(vector, b); Vector3 vector2 = prevFrame.Euler3Speed.ComponentsToVector3(); if (true) { Vector3 vector3 = Quaternion.Inverse(prevFrame.rotation) * vector2; if (vector.x == 0f) { vector.x = SlowingThrust(vector3.x, b.x); } if (vector.y == 0f) { vector.y = SlowingThrust(vector3.y, b.y); } if (vector.z == 0f) { vector.z = SlowingThrust(vector3.z, b.z); } } Vector3 b2 = prevFrame.rotation * vector; Vector3 v = vector2 + b2; vector2 = ClampToRotatedBox(v, options.maxTurnSpeed.ComponentsToVector3(), prevFrame.rotation); Euler3 euler3Speed = default(Euler3); euler3Speed.ComponentsFromVector3(vector2); Vector3 linearSpeed = AdvanceLinearSpeed(prevFrame, options); Vector3 strafeSpeed = AdvanceStrafingSpeed(prevFrame, options, 0f, 0f); Euler3 nextEuler = prevFrame.NextEuler3; MovementFrame result = new MovementFrame(prevFrame.nextPosition, nextEuler, linearSpeed, strafeSpeed, euler3Speed); result.mode = 2; Quaternion rotationDelta = nextEuler.rotation * Quaternion.Inverse(prevFrame.rotation) * Quaternion.identity; //result.ActiveThrusterEffects = DetermineThrusterEffects(rotationDelta, 0f, 0f); return(result); }
public static MovementFrame MoveToDirectionWithoutRoll(MovementFrame prevFrame, Euler3 targetEuler3, MovementOptions options) { Quaternion rotation = prevFrame.Euler3Speed.rotation; Quaternion q = Quaternion.FromToRotation(prevFrame.euler3.direction, targetEuler3.direction); Quaternion lhs = ScaleWithMax(q, 2f, options.yawMaxSpeed); Quaternion q2 = lhs * Quaternion.Inverse(rotation); Quaternion to = ScaleWithMax(q2, 8f, options.yawAcceleration); Quaternion changePerSecond = Quaternion.RotateTowards(Quaternion.identity, to, options.yawAcceleration); Quaternion to2 = Euler3.RotateOverTime(rotation, changePerSecond, 0.1f); Quaternion quat = Quaternion.RotateTowards(Quaternion.identity, to2, options.yawMaxSpeed); Euler3 euler3Speed = Euler3.Rotation(quat); Vector3 linearSpeed = AdvanceLinearSpeed(prevFrame, options); Vector3 strafeSpeed = AdvanceStrafingSpeed(prevFrame, options, 0f, 0f); Euler3 nextEuler = prevFrame.NextEuler3; MovementFrame result = new MovementFrame(prevFrame.nextPosition, nextEuler, linearSpeed, strafeSpeed, euler3Speed); result.mode = 2; Quaternion rotationDelta = nextEuler.rotation * Quaternion.Inverse(prevFrame.rotation) * Quaternion.identity; //result.ActiveThrusterEffects = DetermineThrusterEffects(rotationDelta, 0f, 0f); return(result); }
public static MovementFrame TurnByPitchYawStrikes(MovementFrame prevFrame, Vector3 pitchYawRollFactor, Vector3 strafeDirection, float strafeMagnitude, MovementOptions options) { Vector3 a = options.maxTurnAcceleration.ComponentsToVector3(); Vector3 scale = options.maxTurnSpeed.ComponentsToVector3(); Vector3 nextPosition = prevFrame.nextPosition; Euler3 nextEuler = prevFrame.NextEuler3; Quaternion rotation = nextEuler.rotation; ClampVectorComponents(ref pitchYawRollFactor, -1, 1); Vector3 linearSpeed = AdvanceLinearSpeed(prevFrame, options); float strafeX = strafeDirection.x * strafeMagnitude; float strafeY = strafeDirection.y * strafeMagnitude; Vector3 strafeSpeed = AdvanceStrafingSpeed(prevFrame, options, strafeX, strafeY); Quaternion rotation2 = Quaternion.Inverse(rotation); Vector3 vector = rotation2 * prevFrame.Euler3Speed.ComponentsToVector3(); Vector3 a2 = pitchYawRollFactor; a2.Scale(scale); Vector3 vec = a2 - vector; Vector3 vector2 = a * 0.1f; ClampVectorComponents(ref vec, -vector2, vector2); Vector3 vector3 = vector; vector3 += vec; if (Mathf.Abs(pitchYawRollFactor.z) < 0.01f) { vector3.z = GetNewSpeed(vector3.z, 0f, options.rollAcceleration); } Vector3 vector4 = rotation * vector3; MovementFrame result = new MovementFrame(euler3Speed: new Euler3(vector4.x, vector4.y, vector4.z), position: nextPosition, euler3: nextEuler, linearSpeed: linearSpeed, strafeSpeed: strafeSpeed); result.mode = 2; Quaternion rotationDelta = rotation * Quaternion.Inverse(prevFrame.rotation) * Quaternion.identity; //result.ActiveThrusterEffects = DetermineThrusterEffects(rotationDelta, strafeX, strafeY); return(result); }
public Euler3 MinEulerSpeed(Euler3 euler3) { return(new Euler3(MinPitchSpeed(euler3.pitch), MinYawSpeed(euler3.roll, euler3.pitch), MinRollSpeed(euler3.roll))); }
public Euler3 MaxEulerSpeed(Euler3 euler3) { return(new Euler3(MaxPitchSpeed(euler3.pitch), MaxYawSpeed(euler3.roll, euler3.pitch), MaxRollSpeed(euler3.roll))); }
public static MovementFrame WASD(MovementFrame prevFrame, int pitch, int yaw, int roll, MovementOptions options) { Euler3 euler = prevFrame.euler3; Euler3 to = options.MaxEulerSpeed(euler); Euler3 from = options.MinEulerSpeed(euler); float num = 0f; if (yaw > 0) { num = 0f - options.maxRoll; } if (yaw < 0) { num = options.maxRoll; } float num2 = Algorithm3D.NormalizeAngle(num - euler.roll); Euler3 zero = Euler3.zero; zero.roll = options.rollAcceleration * (num2 / options.maxRoll - prevFrame.Euler3Speed.roll * options.rollFading / options.rollMaxSpeed); if (yaw != 0) { zero.yaw = (float)yaw * options.yawAcceleration; } else if (prevFrame.Euler3Speed.yaw > Mathf.Epsilon) { zero.yaw = (0f - options.yawAcceleration) * options.yawFading; from.yaw = 0f; } else if (prevFrame.Euler3Speed.yaw < 0f - Mathf.Epsilon) { zero.yaw = options.yawAcceleration * options.yawFading; to.yaw = 0f; } if (pitch != 0) { zero.pitch = (float)pitch * options.pitchAcceleration; } else if (prevFrame.Euler3Speed.pitch > Mathf.Epsilon) { zero.pitch = (0f - options.pitchAcceleration) * options.pitchFading; from.pitch = 0f; } else if (prevFrame.Euler3Speed.pitch < 0f - Mathf.Epsilon) { zero.pitch = options.pitchAcceleration * options.pitchFading; to.pitch = 0f; } Euler3 euler3Speed = prevFrame.Euler3Speed + zero * 0.1f; euler3Speed.Clamp(from, to); Vector3 linearSpeed = AdvanceLinearSpeed(prevFrame, options); Vector3 strafeSpeed = AdvanceStrafingSpeed(prevFrame, options, 0f, 0f); Euler3 nextEuler = prevFrame.NextEuler3; MovementFrame result = new MovementFrame(prevFrame.nextPosition, nextEuler, linearSpeed, strafeSpeed, euler3Speed); Quaternion rotationDelta = nextEuler.rotation * Quaternion.Inverse(prevFrame.rotation) * Quaternion.identity; //result.ActiveThrusterEffects = DetermineThrusterEffects(rotationDelta, 0f, 0f); if (pitch != 0) { result.mode = 1; } return(result); }
public void Clamp(Euler3 from, Euler3 to) { pitch = Mathf.Clamp(pitch, from.pitch, to.pitch); yaw = Mathf.Clamp(yaw, from.yaw, to.yaw); roll = Mathf.Clamp(roll, from.roll, to.roll); }
public static MovementFrame TurnToDirectionStrikes(MovementFrame prevFrame, Euler3 targetEuler3, float roll, float strafeX, float strafeY, MovementOptions options) { Vector3 vector = options.maxTurnAcceleration.ComponentsToVector3(); Vector3 a = FindDamping(vector, options.maxTurnSpeed.ComponentsToVector3()); float d = 3f; Vector3 vector2 = options.maxTurnSpeed.ComponentsToVector3(); Vector3 nextPosition = prevFrame.nextPosition; Euler3 nextEuler = prevFrame.NextEuler3; Quaternion rotation = nextEuler.rotation; Vector3 point = targetEuler3.rotation * Vector3.forward; roll = Mathf.Clamp(roll, -1f, 1f); Vector3 linearSpeed = AdvanceLinearSpeed(prevFrame, options); Quaternion rotation2 = Quaternion.Inverse(rotation); Vector3 toDirection = rotation2 * point; Vector3 vector3 = rotation2 * prevFrame.Euler3Speed.ComponentsToVector3(); Vector3 eulerAngles = Quaternion.FromToRotation(Vector3.forward, toDirection).eulerAngles; eulerAngles = KeepVectorComponentsWithinPlusMinus180(eulerAngles); Vector3 a2 = FindVelocityForRotationDelta(eulerAngles, a * d); Vector3 scale = Vector3.one - a * 0.1f; Vector3 vector4 = vector3; vector4.Scale(scale); Vector3 scale2 = Vector3.one - a * d * 0.1f; Vector3 vector5 = vector3; vector5.Scale(scale2); bool flag = false; bool flag2 = false; if (Mathf.Abs(vector4.x) > Mathf.Abs(a2.x)) { scale.x = Mathf.Max(scale2.x, a2.x / vector3.x); flag = true; } if (Mathf.Abs(vector4.y) > Mathf.Abs(a2.y)) { scale.y = Mathf.Max(scale2.y, a2.y / vector3.y); flag2 = true; } vector3.Scale(scale); Vector3 a3 = ScalePitchYawSoThatOneOfThemHasLengthOneAndSetZToZero(eulerAngles); Vector3 scale3 = vector; a3.Scale(scale3); Vector3 vector6 = a2 - vector3; if (Mathf.Abs(a3.x) > Mathf.Abs(vector6.x)) { a3.x = vector6.x; } if (Mathf.Abs(a3.y) > Mathf.Abs(vector6.y)) { a3.y = vector6.y; } if (flag) { a3.x = 0f; } if (flag2) { a3.y = 0f; } float num = vector.z * roll; vector3.z += num * 0.1f; Vector3 val = vector3 + a3 * 0.1f; val = Clamp(val, -vector2, vector2); Vector3 point2 = val; Vector3 vector7 = rotation * point2; Euler3 euler3Speed = new Euler3(vector7.x, vector7.y, vector7.z); Vector3 strafeSpeed = AdvanceStrafingSpeed(prevFrame, options, 0f, 0f); MovementFrame result = new MovementFrame(nextPosition, nextEuler, linearSpeed, strafeSpeed, euler3Speed); result.mode = 2; Quaternion rotationDelta = rotation * Quaternion.Inverse(prevFrame.rotation) * Quaternion.identity; //result.ActiveThrusterEffects = DetermineThrusterEffects(rotationDelta, strafeX, strafeY); return(result); }
public void ClampMax(Euler3 max) { pitch = Mathf.Min(pitch, max.pitch); yaw = Mathf.Min(yaw, max.yaw); roll = Mathf.Min(roll, max.roll); }
public static Euler3 RotateOverTimeLocal(Euler3 start, Euler3 changePerSecond, float dt) { Quaternion rhs = Quaternion.Slerp(Quaternion.identity, changePerSecond.rotation, dt); return(Rotation(start.rotation * rhs)); }
public void ClampMin(Euler3 min) { pitch = Mathf.Max(pitch, min.pitch); yaw = Mathf.Max(yaw, min.yaw); roll = Mathf.Max(roll, min.roll); }
public static Euler3 Scale(Euler3 a, Euler3 b) { return(new Euler3(a.pitch * b.pitch, a.yaw * b.yaw, a.roll * b.roll)); }