Question Rotating an Object Towards Another

Hello,

I'm currently attempting to create homing projectiles. This works so far by rotating the projectile towards the desired object (using https://discussions.unity.com/t/how-do-i-rotate-an-object-towards-a-vector3-point/42488 as the method of doing so). This works alongside the projectile's default movement, which, for the purposes of testing, is linear. This means it will always move Left. Here is the example code:

Code (CSharp):

1. transform.Translate(Vector3.left * velocity * Time.deltaTime);
2. distanceTravelled += velocity * Time.deltaTime;

Obviously, "left" is relative to the object's rotation, so the rotation of the projectile is based on the rotation of the weapon, which is based on the position of the user's cursor. The linear aspect works exactly as expected.

However, the homing gets weird. Here is the code for the object rotation:

Code (CSharp):

1. direction = Vector3.Normalize(homingTarget.transform.position - gameObject.transform.position);
2. lookRotation = Quaternion.LookRotation(direction);
3. Vector3 q = Quaternion.Slerp(gameObject.transform.rotation, lookRotation, Time.deltaTime * homingStrength * 20).eulerAngles;
4. q.x = 0;
5. q.y = 0;
6. gameObject.transform.rotation = Quaternion.Euler(q);

homingTarget is found by taking the nearest GameObject with the "Enemy" tag to the projectile. I'm reasonably confident this works as intended. The x and y rotations are set to 0 because this is a 2D game, and we need not worry ourselves with x and y rotation in a 2D game.

The issue is that the homing works perfectly fine when my cursor is pointed true left, but as I rotate over to the right, up, or down, the projectiles begin rotating away from the GameObjects they're supposed to be tracking. My running hypothesis is that the initial rotation of a GameObject affects future changes to "rotation" somehow.

I'm wondering if anybody can give me pointers or ideas as to what my be wrong here.

 

Here was my implementation:

Full source and setup package here:

https://forum.unity.com/threads/gently-rotating-toward-an-object.922352/#post-6041018

Otherwise, if you wanna debug the above, here's how:

Time to start debugging! Here is how you can begin your exciting new debugging adventures:

You must find a way to get the information you need in order to reason about what the problem is.

Once you understand what the problem is, you may begin to reason about a solution to the problem.

What is often happening in these cases is one of the following:

- the code you think is executing is not actually executing at all
- the code is executing far EARLIER or LATER than you think
- the code is executing far LESS OFTEN than you think
- the code is executing far MORE OFTEN than you think
- the code is executing on another GameObject than you think it is
- you're getting an error or warning and you haven't noticed it in the console window

To help gain more insight into your problem, I recommend liberally sprinkling

Debug.Log()

statements through your code to display information in realtime.

Doing this should help you answer these types of questions:

- is this code even running? which parts are running? how often does it run? what order does it run in?
- what are the names of the GameObjects or Components involved?
- what are the values of the variables involved? Are they initialized? Are the values reasonable?
- are you meeting ALL the requirements to receive callbacks such as triggers / colliders (review the documentation)

Knowing this information will help you reason about the behavior you are seeing.

You can also supply a second argument to Debug.Log() and when you click the message, it will highlight the object in scene, such as

Debug.Log("Problem!",this);

If your problem would benefit from in-scene or in-game visualization, Debug.DrawRay() or Debug.DrawLine() can help you visualize things like rays (used in raycasting) or distances.

You can also call Debug.Break() to pause the Editor when certain interesting pieces of code run, and then study the scene manually, looking for all the parts, where they are, what scripts are on them, etc.

You can also call GameObject.CreatePrimitive() to emplace debug-marker-ish objects in the scene at runtime.

You could also just display various important quantities in UI Text elements to watch them change as you play the game.

Visit Google for how to see console output from builds. If you are running a mobile device you can also view the console output. Google for how on your particular mobile target, such as this answer for iOS: https://forum.unity.com/threads/how-to-capturing-device-logs-on-ios.529920/ or this answer for Android: https://forum.unity.com/threads/how-to-capturing-device-logs-on-android.528680/

If you are working in VR, it might be useful to make your on onscreen log output, or integrate one from the asset store, so you can see what is happening as you operate your software.

Another useful approach is to temporarily strip out everything besides what is necessary to prove your issue. This can simplify and isolate compounding effects of other items in your scene or prefab.

If your problem is with OnCollision-type functions, print the name of what is passed in!

Here's an example of putting in a laser-focused Debug.Log() and how that can save you a TON of time wallowing around speculating what might be going wrong:

https://forum.unity.com/threads/coroutine-missing-hint-and-error.1103197/#post-7100494

"When in doubt, print it out!(tm)" - Kurt Dekker (and many others)

Note: the

print()

function is an alias for Debug.Log() provided by the MonoBehaviour class.

 

I appreciate the reply, but I wouldn't be posting here if I hadn't exhausted tons of debug options. It's not an issue with the code (well, it is, but not in terms of it being a "whoops" bug), it's an issue with the understanding of the math. I've completed my fair share of Linear Algebra and Multivariable Calc courses, but I had never seen the word "Quaternion" until I started working with Unity. Suffice it to say, there's a challenge in understanding what exactly my Objects are actually tracking.

Regardless of how I implement the tracking algorithm (one I made, the one I linked to, yours), it continues to have the same bug every time, where the left side tracks mostly fine, but it ends up just turning *mostly* left. Not to the same location, just to some general point on the left side of the screen until it gets into range of something to its left, relative to the world.

I made this post to see if anybody has had similar issues with rotations and leftward movement behaving unexpectedly and if there were any solutions to that.

 

I think your Translate() line probably just needs to use

Vector3.forward

instead of .left