/// <summary>
/// Calculate the angle it needs to rotate fromm the position of picker.
/// </summary>
/// <param name="picker">Picker that is grasping the object</param>
/// <returns>Angle it needs to rotate itself</returns>
protected float GetAdjustedCurrentAngleFromPicker(IPicker picker)
{
// Get picker's current angle of rotation from zero
float pickerAngle = GetPickerAngleInRotationAxis(picker);
// Get how much picker has rotated from the start of grasping
float angleDiff = pickerAngle - PickerAngleOffset;
// Decide which way to rotate by adjusting the target angle into range of
// (reference - 180, reference + 180] such that it can be seen from the
// adjusted angle which side of the reference the angle is. In this case,
// target angle is PickableAngleOffset + angleDiff. The reference angle
// is LastPickableAngle.
float currentAngle = RotationUtils.AdjustAngleByReference(
PickableAngleOffset + angleDiff, LastPickableAngle);
// Clamp current angle to angle limit
currentAngle = UnlimitedRotation
? Mathf.Clamp(currentAngle, -360, 360)
: Mathf.Clamp(currentAngle, 0, _angleLimit);
return(currentAngle);
}
/// <summary>
/// Find the target angle of rotation from zero based on current picker's rotation.
/// </summary>
/// <remarks>
/// The picker will maintain a fixed relative rotation with knob since the start of
/// grasping, so given the current rotation of picker, we can compute the new target
/// rotation of knob.
/// </remarks>
/// <param name="picker">The picker that is grasping it.</param>
/// <returns>Target angle of rotation of knob based on the picker's rotation.</returns>
protected override float GetPickerAngleInRotationAxis(IPicker picker)
{
PickerDexmo pickerDexmo = picker as PickerDexmo;
Transform pickerReference = pickerDexmo == null ? picker.Transform : pickerDexmo.PalmCenter;
// Calculate the target rotation of knob based on current rotation of the picker
Quaternion newKnobTargetRotation = pickerReference.rotation *
Quaternion.Inverse(_pickerRelativeRotationWrtKnob);
// Convert the current angle reference from world coordinate to parent transform's
// coordinate. Angle reference is the direction that indicates the current angle
// of rotation from zero.
Vector3 newAngleReferenceDirectionInWorld = newKnobTargetRotation * ZeroReferenceDirection;
Vector3 pickerRelativeDirectionInParentCoordinate =
Miscellaneous.InverseTransformDirectionInParentCoordinate(transform,
newAngleReferenceDirectionInWorld);
// Find the target angle of rotation from zero in the plane normal to rotation axis
float angle = RotationUtils.AngleInPlane(LocalRotationAxisInParentCoordinate,
ZeroReferenceDirectionInParentCoordinate, pickerRelativeDirectionInParentCoordinate);
return(angle);
}
public bool isInAttackArea(float lowAngle, float highAngle, float nearRadius, float farRadius)
{
float spriteRadius = transform.Find("Sprite").GetComponent <SpriteRenderer>().bounds.size.x / 2;
float distanceToBossActual = Mathf.Max(Vector3.Distance(Vector3.zero, transform.position), 0);
float distanceToBossFar = distanceToBossActual + spriteRadius;
float distanceToBossNear = distanceToBossActual - spriteRadius;
RadialPosition radialPosition = RotationUtils.XYToRadialPos(this.transform.position);
float enemyWidthAngle = Mathf.Rad2Deg * Mathf.Acos(1 - Mathf.Pow(spriteRadius / Mathf.Sqrt(2 * distanceToBossActual), 2));
float enemyHighAngle = radialPosition.GetAngle() + enemyWidthAngle;
float enemyLowAngle = radialPosition.GetAngle() - enemyWidthAngle;
bool inHighAngle = RotationUtils.InCounterClockwiseLimits(enemyHighAngle, lowAngle, highAngle);
bool inLowAngle = RotationUtils.InCounterClockwiseLimits(enemyLowAngle, lowAngle, highAngle);
bool bossLargerThanRadius = RotationUtils.InCounterClockwiseLimits(lowAngle, enemyLowAngle, enemyHighAngle) &&
RotationUtils.InCounterClockwiseLimits(highAngle, enemyLowAngle, enemyHighAngle);
bool inRadius = distanceToBossNear <= farRadius && distanceToBossFar >= nearRadius;
return((inLowAngle || inHighAngle || bossLargerThanRadius) && inRadius);
}
public void UpdateRotation(float newRot)
{
transform.parent.eulerAngles = new Vector3(0, 0, newRot); //Update rotation previous to checking limits
//Find biggest of low limits and smallest of high limis to create the smallest allowed intervall
float tmpLowLimit = RotationUtils.InCounterClockwiseLimits(lowFrameTwistLimit, lowHardTwistLimit, highHardTwistLimit) ? lowFrameTwistLimit : lowHardTwistLimit;
float tmpHighLimit = RotationUtils.InCounterClockwiseLimits(highFrameTwistLimit, lowHardTwistLimit, highHardTwistLimit) ? highFrameTwistLimit : highHardTwistLimit;
float rotation = transform.parent.localEulerAngles.z;
if (RotationUtils.InCounterClockwiseLimits(rotation, tmpLowLimit, tmpHighLimit))
{
//Angle in limit
outHigh = false;
outLow = false;
}
else
{
if (outHigh) //Rotation is still outside limits to one side
{
transform.parent.localEulerAngles = new Vector3(0, 0, tmpHighLimit);
}
else if (outLow) //Rotation is still outside limits to the other side
{
transform.parent.localEulerAngles = new Vector3(0, 0, tmpLowLimit);
}
// Check to which side rotation has exited the limits intervall.
// If it is not yet in one of the halves of the outside of the twist limits, wait until it is.
else if (RotationUtils.InCounterClockwiseLimits(rotation, RotationUtils.MiddleOfRotations(tmpHighLimit, tmpLowLimit), tmpLowLimit))
{
outLow = true;
transform.parent.localEulerAngles = new Vector3(0, 0, tmpLowLimit);
}
else if (RotationUtils.InCounterClockwiseLimits(rotation, tmpLowLimit, RotationUtils.MiddleOfRotations(tmpHighLimit, tmpLowLimit)))
{
outHigh = true;
transform.parent.localEulerAngles = new Vector3(0, 0, tmpHighLimit);
}
}
}
/// <summary>
/// Blends two frames to create a new frame.
/// </summary>
/// <returns>The new blended frame.</returns>
/// <param name="fromFrame">The first frame.</param>
/// <param name="toFrame">The second frame.</param>
/// <param name="percentage">The percentage to add from the second frame to the first frame.
/// At 0 percent, the blended frame is identical to the first, and 100 it is identical to the secont</param>
public Frame BlendFrames(Frame fromFrame, Frame toFrame, int percentage)
{
List <string> bodyPartNames = fromFrame.getBodyPartNames();
Frame newFrame = (Frame)fromFrame.Clone();
foreach (string name in bodyPartNames)
{
float newRotation;
float fromRot = fromFrame.getRotation(name);
float toRot = toFrame.getRotation(name);
//Make sure rotation around zero does not result in a loop in the wrong direction.
//Make the angle right of zero (the smaller angle) bigger.
if (RotationUtils.ZeroInSmallerLimit(fromRot, toRot))
{
if (fromRot < toRot)
{
fromRot += 360;
}
else if (fromRot > toRot)
{
toRot += 360;
}
//Make sure rotation 0 <=> [180-359] does not rotate the wrong way.
}
else if (fromRot == 0 && toRot > 180)
{
fromRot += 360;
}
else if (toRot == 0 && fromRot > 180)
{
toRot += 360;
}
newRotation = fromRot + (float)percentage / (float)100 * (toRot - fromRot);
newFrame.AddBodyPartRotation(name, newRotation);
}
return(newFrame);
}
void doAttack()
{
Color color = UnityUtils.RecursiveFind(transform, "Image").GetComponent <Image>().color;
color.a = 0.0f;
float unitCircleRotation = RotationUtils.MakePositiveAngle(transform.eulerAngles.z + 90);
Color zeroAlphaColor = color;
zeroAlphaColor.a = 0.0f;
object[] obj = GameObject.FindObjectsOfType(typeof(GameObject));
foreach (Enemy enemy in GameObject.FindObjectsOfType(typeof(Enemy)))
{
if (enemy.isInAttackArea(unitCircleRotation - this.currentAttack.angle,
unitCircleRotation + this.currentAttack.angle,
this.currentAttack.closeRadius,
this.currentAttack.farRadius))
{
enemy.applyDamageTo(this.currentAttack.damage);
}
}
// For now, change color of boss when he is attacking
// TODO: Change when areas of damage is implemented
gameObject.GetComponent <SpriteRenderer>().color = Color.red;
if (currentCooldownBehaviour != null)
{
currentCooldownBehaviour.RestartCooldown();
}
this.aimColorModifier.FadeToSelected(this.currentAttack.frequency);
StartCoroutine(UnityUtils.ChangeToColorAfterTime(gameObject.GetComponent <SpriteRenderer>(), Color.white, 0.5f));
}
public void MoveTo(RadialPosition radialPosition)
{
transform.position = RotationUtils.RadialPosToXY(radialPosition);
}
public void AddAngle(float addedAngle)
{
this.angle += addedAngle;
this.angle = RotationUtils.MakePositiveAngle(angle);
}
public void SetAngle(float angle)
{
angle = RotationUtils.MakePositiveAngle(angle);
this.angle = angle;
}
