Resolved: Unity: How to rotate child weapon around pivot point in its local space

In this post, we will see how to resolve Unity: How to rotate child weapon around pivot point in its local space

Question:

In my 2D game, the player Prefab has children which are weapons (like swords) so that when the player moves, the weapons translate in world space with his movements while maintaining a constant local position (until of course it is time to attack). The weapons automatically point towards nearby enemies, and swing when they get close enough.
I want the weapon to follow a swing arc by rotating around a pivot point defined at half of the weapon’s range in the direction of the enemy. Once the weapon starts the swing, the arc’s local position and rotation should remain unchanged and no longer care about the enemy position while the world arc will obviously translate with the player. The weapon should follow this arc purely relative to the player.
RotateAround seems to only work in world space, and thus causes strange problems when trying to rotate around an object in world space while the weapon’s world position (as well as my desired pivot point’s world position) would be translating with the player. Also, the point that I need it to rotate around needs to be relative to the local space, since when the player moves, the weapon needs to maintain its local arc while also translating with the player.
I also tried using Vector3.Slerp on the weapon’s transform.localPosition, which seemed like it would be the perfect solution, but I can’t seem to get the arc to match what I envision a good round swing would look like.
The attack consists of three parts: Backswing, Foreswing, and Recovery. The part that I care most about is the foreswing arc, as the others can be acheived easily with simply local rotations and lerping.

const int BACKSWING = 0;
const int FORESWING = 1;
const int RECOVER = 2;
float[] timeFrac = { .15f, .25f, .6f };
float[] rotations = { 120f, -240f, 120f };
float backSwingDistMultiplier = .5f;


//Swing Attack
public override IEnumerator Attack(float startAngle) {

    var totalAttackTime = GetAttackTime();
    var backSwingDist = backSwingDistMultiplier * Range;
    var startPos = transform.localPosition;
    var slerpCenterDiff = PerpDir(dir).normalized;

    //Interpolation arrays
    float[] swingTimes = { timeFrac[BACKSWING] * totalAttackTime,
                           timeFrac[FORESWING] * totalAttackTime,
                           timeFrac[RECOVER] * totalAttackTime };

    float[] startAngles = { startAngle,
                            startAngle + rotations[BACKSWING],
                            startAngle + rotations[BACKSWING] + rotations[FORESWING] };

    Vector3[] swingPositions = { startPos - (dir - slerpCenterDiff ) * backSwingDist,
                                 startPos + dir * Range + slerpCenterDiff * backSwingDist };

    Vector3[] slerpCenters = { (startPos + swingPositions[BACKSWING]) * .5f + slerpCenterDiff ,
                            ((swingPositions[BACKSWING] + swingPositions[FORESWING]) * .5f) + slerpCenterDiff };

    Vector3[] slerpStarts = { startPos - slerpCenters[BACKSWING],
                              swingPositions[BACKSWING] - slerpCenters[FORESWING]};

    Vector3[] slerpEnds = { swingPositions[BACKSWING] - slerpCenters[BACKSWING],
                            swingPositions[FORESWING] - slerpCenters[FORESWING]};
    
    timer = 0;
    float percentDone;
    //A swing attack has backswing, foreswing, and recovery
    for (int swing = 0; swing <= 2; swing++) {
        while (timer < swingTimes[swing]) {
            percentDone = timer / swingTimes[swing];

            //Backswing and Foreswing will slerp
            if (swing < RECOVER) {
                transform.localPosition = Vector3.Slerp(slerpStarts[swing], slerpEnds[swing], percentDone);
                transform.localPosition += slerpCenters[swing];
            } else { //Recover will lerp
                transform.localPosition = Vector3.Lerp(swingPositions[FORESWING], startPos, percentDone);
            }
            transform.localRotation = Quaternion.Euler(0, 0, 
                startAngles[swing] + rotations[swing] * percentDone);
            timer += Time.deltaTime;
            yield return null;
        }
        transform.localRotation = Quaternion.Euler(0, 0, startAngles[swing] + rotations[swing]);

        timer -= swingTimes[swing];
    }
    transform.localPosition = startPos;
}

I would just make an animation out of it, but I need the range to be dynamic, which is next to impossible to achieve with keyframes.

Best Answer:

I was able to get my desired outcome by defining the arc centers in localPosition first:

var backswingArcCenter = (startPos + swingPositions[BACKSWING]) * 0.5f;
var foreswingArcCenter = (swingPositions[BACKSWING] + swingPositions[FORESWING]) * 0.5f;

and then calling RotateAround using that position added to the player’s world space

if (swing == FORESWING) {
    transform.RotateAround(player.transform.position + foreswingArcCenter, 
           Vector3.forward, Time.deltaTime / swingTimes[swing] * 270f);
} else if (swing == BACKSWING) {
    transform.RotateAround(player.transform.position + backswingArcCenter,
           Vector3.forward, Time.deltaTime / swingTimes[swing] * -180f);
}

If you have better answer, please add a comment about this, thank you!

Source: Stackoverflow.com

Question:

Best Answer:

Related