# Lock rotation of object

How would I lock the rotation of an object to 1 axis? I've got a turret on a tank that follows the player. Unfortunately, it'll follow so strictly that if the player gets too close to the tank, the turret will go through the tank in order to continue following the player. I don't like that. How would I fix it?

Any help greatly appreciated - Frustrated developer

EDIT: Here's the script:

``````var attackRange = 30.0;
var shootAngleDistance = 10.0;
var target : Transform;

function Start () {
if (target == null && GameObject.FindWithTag("Player"))
target = GameObject.FindWithTag("Player").transform;
}

function Update () {
if (target == null)
return;

if (!CanSeeTarget ())
return;

// Rotate towards target
var targetPoint = target.position;
var targetRotation = Quaternion.LookRotation (targetPoint -     transform.position, Vector3.up);
transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, Time.deltaTime * 2.0);

// If we are almost rotated towards target - fire one clip of ammo
var forward = transform.TransformDirection(Vector3.forward);
var targetDir = target.position - transform.position;
if (Vector3.Angle(forward, targetDir) < shootAngleDistance)
SendMessage("Fire");
}

function CanSeeTarget () : boolean
{
if (Vector3.Distance(transform.position, target.position) > attackRange)
return false;

var hit : RaycastHit;
if (Physics.Linecast (transform.position, target.position, hit))
return hit.transform == target;

return false;
}

``````

Sometimes what I do is just this:

``````
float lockPos = 0;

void Update()
{
transform.rotation = Quaternion.Euler(transform.rotation.eulerAngles.x, lockPos, lockPos);
}

``````

Whatever you set the "lockPos" to, is what the axes will lock at.

And wherever you feed back its own rotation (transform.rotation.eulerAngles.x, for instance), is a "free angle", and will not be locked.

The same thing can be done to position, as well, to lock an object to one or two axes.

A Configurable Joint will also work, but may not be the correct solution depending on your game. I've used both ways in various objects, and each has its place. It just depends upon your particular code/object.

Edit: Sorry, you're using JavaScript... this is what it would be, I believe (I don't know Javascript all that well, so it may not be exact):

``````
var lockPos = 0;

function Update()
{
transform.rotation = Quaternion.Euler(transform.rotation.eulerAngles.x, lockPos, lockPos);
}

``````

In the script you posted, after the "var targetPoint" line, insert this:

``````    targetPoint.y = transform.position.y;

``````

Then it will only rotate around the Y axis, since the target point will always be on the same plane as the turret.

Well, like I meant on the comment: d'oh. Colliders will be overwritten by any script, and you already showed yours were doing just that. I should have noted that before.

So you may need to go with either OnCollisionStay or OnTriggerStay. The second is not set every frame, so you'd have to try it and see if it behaviors is accepted. I'll give an instance on it because it's simpler! :P

By the way, if you still haven't done so, add a rigidbody as a requirement for the collider to actually collide (see Static vs Rigidbody Colliders on the link).

Then you should add a variable to check if the turret is coliding with the tank and verify it using OnTriggerStay and OnTriggerExit.

It could be something like this:

``````private var lastTransform : Transform;
function OnTriggerStay (other : Collider) {
if (other.tag = "turret") {
transform.rotation = lastTransform;
}
}

// This goes on the Update function, right before the transform.rotation
lastTransform = transform.rotation;
transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, Time.deltaTime * 2.0);

``````

That must be enough. But if for whatever reason it isn't, you'll also need to add a boolean and check for that var before actually rotating the turret. Something like this:

``````private var canRotate = true;
private var lastTransform : Transform;
function OnTriggerStay (other : Collider) {
OnTriggerExit();
if (other.tag = "turret") {
canRotate = false;
transform.rotation = lastTransform;
}
}
function OnTriggerExit () {canRotate = true;}

// This goes on the Update function, right before the transform.rotation
if (canRotate) {
lastTransform = transform.rotation;
transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, Time.deltaTime * 2.0);
}

``````

Note that this won't work just with that alone because the turret will just stop once it collides and nothing will make it exit!

second attempt:

Ok, so C.Joint didn't work for you... That became clear by reading your code now. Unless you're making a 2D game, it's very unlikely C.Joint would be useful in your case. The code was also actually not needed there, but it helped to elucidate the question (which was almost enough in itself).

I think what you need there is adding colliders to the tank and the turret, where the turret goes through to avoid that from happening. That's the whole point of colliders. Learn more about them, it should be enough to make the turret stop going through.

first attempt:

Well, to lock rotation to 1 axis you can simply add a Configurable Joint to it, and lock the other 2 "Angular Motion".

As for the rest, like Michael said, we need more details to help you.

Anyway, since we're here, I'd like to add: always avoid using "Find" as much as possible because it's slow and resource hungry. It would probably not make much difference in this case, but I still rather give you the example of a better usage. It's not an optimal solution:

``````function Start () {
findPlayer = GameObject.FindWithTag("Player").transform;
if (target == null && findPlayer)
target = findPlayer;
}

``````

Everyone… Much similar than worrying about locking an Axis… I have wasted too much time on this, trying to calculate the angle and solve the BS… Apparently Quaternion.LookRotation, does this without having to work about correcting angles, or flipping! Amazing! Unity - Scripting API: Quaternion.LookRotation
Hope this helps:
private void SetRotationFromWorldPoint(Transform trans, Vector3 worldPoint)
{
Quaternion currentRotation = trans.rotation;
currentRotation = Quaternion.LookRotation(worldPoint);
trans.rotation = currentRotation;
}