Make sphere rotate when controlled

I recently asked a question, but didn’t get quite the answer I wanted. I want to know how I can get a sphere to rotate when I control it. Using say the wasd keys, I don’t want to have a fixed animation for it, so that it looks more realistic. I tried adding a sphere collider (default) and rigidbody + a box collider to the surface I had it sitting on. But when I went to move it, it seemed to do a little 24th of a rotation and skip back without fully rotating, so it doesn’t look like it’s rolling. What I would like is a sphere that I can control that rotates smoothly along the surface it’s on. Help is greatly appreciated.

Are you sure it’s not rolling? I don’t want to be the guy to state the obvious, but it’s kind of hard to tell when a sphere is rotating, because… well, it’s a sphere, it looks the same from every angle.

If you haven’t already, try adding some sort of texture to the sphere.

Sounds like you might not be multiplying the rotation by Time.deltaTime. And are you using Input.GetAxis or Input.GetKey? Perhaps you can post some code. We can help you more if we can see the problem first hand.

// Require a character controller to be attached to the same game object
@script RequireComponent(CharacterController)

public var idleAnimation : AnimationClip;
public var walkAnimation : AnimationClip;
public var runAnimation : AnimationClip;
public var jumpPoseAnimation : AnimationClip;

public var walkMaxAnimationSpeed : float = 0.75;
public var trotMaxAnimationSpeed : float = 1.0;
public var runMaxAnimationSpeed : float = 1.0;
public var jumpAnimationSpeed : float = 1.15;
public var landAnimationSpeed : float = 1.0;

private var _animation;

enum CharacterState {
Idle = 0,
Walking = 1,
Trotting = 2,
Running = 3,
Jumping = 4,
}

private var _characterState : CharacterState;

// The speed when walking
var walkSpeed = 2.0;
// after trotAfterSeconds of walking we trot with trotSpeed
var trotSpeed = 4.0;
// when pressing “Fire3” button (cmd) we start running
var runSpeed = 6.0;

var inAirControlAcceleration = 3.0;

// How high do we jump when pressing jump and letting go immediately
var jumpHeight = 0.5;

// The gravity for the character
var gravity = 20.0;
// The gravity in controlled descent mode
var speedSmoothing = 10.0;
var rotateSpeed = 500.0;
var trotAfterSeconds = 3.0;

var canJump = true;

private var jumpRepeatTime = 0.05;
private var jumpTimeout = 0.15;
private var groundedTimeout = 0.25;

// The camera doesnt start following the target immediately but waits for a split second to avoid too much waving around.
private var lockCameraTimer = 0.0;

// The current move direction in x-z
private var moveDirection = Vector3.zero;
// The current vertical speed
private var verticalSpeed = 0.0;
// The current x-z move speed
private var moveSpeed = 0.0;

// The last collision flags returned from controller.Move
private var collisionFlags : CollisionFlags;

// Are we jumping? (Initiated with jump button and not grounded yet)
private var jumping = false;
private var jumpingReachedApex = false;

// Are we moving backwards (This locks the camera to not do a 180 degree spin)
private var movingBack = false;
// Is the user pressing any keys?
private var isMoving = false;
// When did the user start walking (Used for going into trot after a while)
private var walkTimeStart = 0.0;
// Last time the jump button was clicked down
private var lastJumpButtonTime = -10.0;
// Last time we performed a jump
private var lastJumpTime = -1.0;

// the height we jumped from (Used to determine for how long to apply extra jump power after jumping.)
private var lastJumpStartHeight = 0.0;

private var inAirVelocity = Vector3.zero;

private var lastGroundedTime = 0.0;

private var isControllable = true;

function Awake ()
{
moveDirection = transform.TransformDirection(Vector3.forward);

_animation = GetComponent(Animation);
if(!_animation)
	Debug.Log("The character you would like to control doesn't have animations. Moving her might look weird.");

/*

public var idleAnimation : AnimationClip;
public var walkAnimation : AnimationClip;
public var runAnimation : AnimationClip;
public var jumpPoseAnimation : AnimationClip;
*/
if(!idleAnimation) {
_animation = null;
Debug.Log(“No idle animation found. Turning off animations.”);
}
if(!walkAnimation) {
_animation = null;
Debug.Log(“No walk animation found. Turning off animations.”);
}
if(!runAnimation) {
_animation = null;
Debug.Log(“No run animation found. Turning off animations.”);
}
if(!jumpPoseAnimation && canJump) {
_animation = null;
Debug.Log(“No jump animation found and the character has canJump enabled. Turning off animations.”);
}

}

function UpdateSmoothedMovementDirection ()
{
var cameraTransform = Camera.main.transform;
var grounded = IsGrounded();

// Forward vector relative to the camera along the x-z plane	
var forward = cameraTransform.TransformDirection(Vector3.forward);
forward.y = 0;
forward = forward.normalized;

// Right vector relative to the camera
// Always orthogonal to the forward vector
var right = Vector3(forward.z, 0, -forward.x);

var v = Input.GetAxisRaw("Vertical");
var h = Input.GetAxisRaw("Horizontal");

// Are we moving backwards or looking backwards
if (v < -0.2)
	movingBack = true;
else
	movingBack = false;

var wasMoving = isMoving;
isMoving = Mathf.Abs (h) > 0.1 || Mathf.Abs (v) > 0.1;
	
// Target direction relative to the camera
var targetDirection = h * right + v * forward;

// Grounded controls
if (grounded)
{
	// Lock camera for short period when transitioning moving & standing still
	lockCameraTimer += Time.deltaTime;
	if (isMoving != wasMoving)
		lockCameraTimer = 0.0;

	// We store speed and direction seperately,
	// so that when the character stands still we still have a valid forward direction
	// moveDirection is always normalized, and we only update it if there is user input.
	if (targetDirection != Vector3.zero)
	{
		// If we are really slow, just snap to the target direction
		if (moveSpeed < walkSpeed * 0.9 && grounded)
		{
			moveDirection = targetDirection.normalized;
		}
		// Otherwise smoothly turn towards it
		else
		{
			moveDirection = Vector3.RotateTowards(moveDirection, targetDirection, rotateSpeed * Mathf.Deg2Rad * Time.deltaTime, 1000);
			
			moveDirection = moveDirection.normalized;
		}
	}
	
	// Smooth the speed based on the current target direction
	var curSmooth = speedSmoothing * Time.deltaTime;
	
	// Choose target speed
	//* We want to support analog input but make sure you cant walk faster diagonally than just forward or sideways
	var targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0);

	_characterState = CharacterState.Idle;
	
	// Pick speed modifier
	if (Input.GetKey (KeyCode.LeftShift) | Input.GetKey (KeyCode.RightShift))
	{
		targetSpeed *= runSpeed;
		_characterState = CharacterState.Running;
	}
	else if (Time.time - trotAfterSeconds > walkTimeStart)
	{
		targetSpeed *= trotSpeed;
		_characterState = CharacterState.Trotting;
	}
	else
	{
		targetSpeed *= walkSpeed;
		_characterState = CharacterState.Walking;
	}
	
	moveSpeed = Mathf.Lerp(moveSpeed, targetSpeed, curSmooth);
	
	// Reset walk time start when we slow down
	if (moveSpeed < walkSpeed * 0.3)
		walkTimeStart = Time.time;
}
// In air controls
else
{
	// Lock camera while in air
	if (jumping)
		lockCameraTimer = 0.0;

	if (isMoving)
		inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration;
}

}

function ApplyJumping ()
{
// Prevent jumping too fast after each other
if (lastJumpTime + jumpRepeatTime > Time.time)
return;

if (IsGrounded()) {
	// Jump
	// - Only when pressing the button down
	// - With a timeout so you can press the button slightly before landing		
	if (canJump && Time.time < lastJumpButtonTime + jumpTimeout) {
		verticalSpeed = CalculateJumpVerticalSpeed (jumpHeight);
		SendMessage("DidJump", SendMessageOptions.DontRequireReceiver);
	}
}

}

function ApplyGravity ()
{
if (isControllable) // don’t move player at all if not controllable.
{
// Apply gravity
var jumpButton = Input.GetButton(“Jump”);

	// When we reach the apex of the jump we send out a message
	if (jumping && !jumpingReachedApex && verticalSpeed <= 0.0)
	{
		jumpingReachedApex = true;
		SendMessage("DidJumpReachApex", SendMessageOptions.DontRequireReceiver);
	}

	if (IsGrounded ())
		verticalSpeed = 0.0;
	else
		verticalSpeed -= gravity * Time.deltaTime;
}

}

function CalculateJumpVerticalSpeed (targetJumpHeight : float)
{
// From the jump height and gravity we deduce the upwards speed
// for the character to reach at the apex.
return Mathf.Sqrt(2 * targetJumpHeight * gravity);
}

function DidJump ()
{
jumping = true;
jumpingReachedApex = false;
lastJumpTime = Time.time;
lastJumpStartHeight = transform.position.y;
lastJumpButtonTime = -10;

_characterState = CharacterState.Jumping;

}

function Update() {

if (!isControllable)
{
	// kill all inputs if not controllable.
	Input.ResetInputAxes();
}

if (Input.GetButtonDown ("Jump"))
{
	lastJumpButtonTime = Time.time;
}

UpdateSmoothedMovementDirection();

// Apply gravity
// - extra power jump modifies gravity
// - controlledDescent mode modifies gravity
ApplyGravity ();

// Apply jumping logic
ApplyJumping ();

// Calculate actual motion
var movement = moveDirection * moveSpeed + Vector3 (0, verticalSpeed, 0) + inAirVelocity;
movement *= Time.deltaTime;

// Move the controller
var controller : CharacterController = GetComponent(CharacterController);
collisionFlags = controller.Move(movement);

// ANIMATION sector
if(_animation) {
	if(_characterState == CharacterState.Jumping) 
	{
		if(!jumpingReachedApex) {
			_animation[jumpPoseAnimation.name].speed = jumpAnimationSpeed;
			_animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
			_animation.CrossFade(jumpPoseAnimation.name);
		} else {
			_animation[jumpPoseAnimation.name].speed = -landAnimationSpeed;
			_animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
			_animation.CrossFade(jumpPoseAnimation.name);				
		}
	} 
	else 
	{
		if(controller.velocity.sqrMagnitude < 0.1) {
			_animation.CrossFade(idleAnimation.name);
		}
		else 
		{
			if(_characterState == CharacterState.Running) {
				_animation[runAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, runMaxAnimationSpeed);
				_animation.CrossFade(runAnimation.name);	
			}
			else if(_characterState == CharacterState.Trotting) {
				_animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, trotMaxAnimationSpeed);
				_animation.CrossFade(walkAnimation.name);	
			}
			else if(_characterState == CharacterState.Walking) {
				_animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, walkMaxAnimationSpeed);
				_animation.CrossFade(walkAnimation.name);	
			}
			
		}
	}
}
// ANIMATION sector

// Set rotation to the move direction
if (IsGrounded())
{
	
	transform.rotation = Quaternion.LookRotation(moveDirection);
		
}	
else
{
	var xzMove = movement;
	xzMove.y = 0;
	if (xzMove.sqrMagnitude > 0.001)
	{
		transform.rotation = Quaternion.LookRotation(xzMove);
	}
}	

// We are in jump mode but just became grounded
if (IsGrounded())
{
	lastGroundedTime = Time.time;
	inAirVelocity = Vector3.zero;
	if (jumping)
	{
		jumping = false;
		SendMessage("DidLand", SendMessageOptions.DontRequireReceiver);
	}
}

}

function OnControllerColliderHit (hit : ControllerColliderHit )
{
// Debug.DrawRay(hit.point, hit.normal);
if (hit.moveDirection.y > 0.01)
return;
}

function GetSpeed () {
return moveSpeed;
}

function IsJumping () {
return jumping;
}

function IsGrounded () {
return (collisionFlags & CollisionFlags.CollidedBelow) != 0;
}

function GetDirection () {
return moveDirection;
}

function IsMovingBackwards () {
return movingBack;
}

function GetLockCameraTimer ()
{
return lockCameraTimer;
}

function IsMoving () : boolean
{
return Mathf.Abs(Input.GetAxisRaw(“Vertical”)) + Mathf.Abs(Input.GetAxisRaw(“Horizontal”)) > 0.5;
}

function HasJumpReachedApex ()
{
return jumpingReachedApex;
}

function IsGroundedWithTimeout ()
{
return lastGroundedTime + groundedTimeout > Time.time;
}

function Reset ()
{
gameObject.tag = “Player”;
}

No ideas?

So I figured out that it is rotating, but from 0-359.9999 in about 0.0000001 seconds. I believe that is the problem, but I haven’t been able to figure it out yet, help is accepted =)

That script you posted seems like it was for a third person controller. Did you write it all yourself? It seems like it has many unnecessary functions (animation…?).

Why not just use a rigidbody instead of a controller and just add torque instead of rotating it? What kind of game are you trying to make? Why it’s not rotating could be from several reasons, but if your game is like what I imagine I don’t think you will need it.

btw a trick to formatting your code: post all your code, then select all of it, THEN press the code button. That works for me. If you want, you can edit your “answer” (or just delete it and put it into the question) so you can format your code better.

it looks like you are setting the rotation of the ball yourself in a couple of places… such as…
transform.rotation = Quaternion.LookRotation(moveDirection);

This will zero out your rotation.

If you are relying on physics and friction to rotare the ball, you should not be setting the rotation anywhere in your script.