WOW Camera Movement

Already heppened flickerings with me too, but now dont have more problems.
Look my Configurations:




Script used:

Code (csharp):

1.  
2. // WowCamera.cs
3. // by Synthetique - [url]http://forum.unity3d.com/viewtopic.php?p=278801#278801[/url]
4.  
5. using UnityEngine;
6. using System.Collections;
7.  
8. public class WowCamera : MonoBehaviour
9. {
10.     public Transform target;
11.    
12.     public float targetHeight = 1.7f;
13.     public float distance = 5.0f;
14.     public float offsetFromWall = 0.1f;
15.  
16.     public float maxDistance = 20;
17.     public float minDistance = .6f;
18.     public float speedDistance = 5;
19.  
20.     public float xSpeed = 200.0f;
21.     public float ySpeed = 200.0f;
22.  
23.     public int yMinLimit = -40;
24.     public int yMaxLimit = 80;
25.  
26.     public int zoomRate = 40;
27.  
28.     public float rotationDampening = 3.0f;
29.     public float zoomDampening = 5.0f;
30.    
31.     public LayerMask collisionLayers = -1;
32.  
33.     private float xDeg = 0.0f;
34.     private float yDeg = 0.0f;
35.     private float currentDistance;
36.     private float desiredDistance;
37.     private float correctedDistance;
38.  
39.     void Start ()
40.     {
41.         Vector3 angles = transform.eulerAngles;
42.         xDeg = angles.x;
43.         yDeg = angles.y;
44.  
45.         currentDistance = distance;
46.         desiredDistance = distance;
47.         correctedDistance = distance;
48.  
49.         // Make the rigid body not change rotation
50.         if (rigidbody)
51.             rigidbody.freezeRotation = true;
52.     }
53.    
54.     /**
55.      * Camera logic on LateUpdate to only update after all character movement logic has been handled.
56.      */
57.     void LateUpdate ()
58.     {
59.         Vector3 vTargetOffset;
60.        
61.        // Don't do anything if target is not defined
62.         if (!target)
63.             return;
64.  
65.         // If either mouse buttons are down, let the mouse govern camera position
66.         if (GUIUtility.hotControl == 0) {
67.             if (Input.GetMouseButton(0) || Input.GetMouseButton(1))
68.             {
69.                 xDeg += Input.GetAxis ("Mouse X") * xSpeed * 0.02f;
70.                 yDeg -= Input.GetAxis ("Mouse Y") * ySpeed * 0.02f;
71.             }
72.        
73.         // otherwise, ease behind the target if any of the directional keys are pressed
74.             else if (Input.GetAxis("Vertical") != 0 || Input.GetAxis("Horizontal") != 0)
75.             {
76.                 float targetRotationAngle = target.eulerAngles.y;
77.                 float currentRotationAngle = transform.eulerAngles.y;
78.                 xDeg = Mathf.LerpAngle (currentRotationAngle, targetRotationAngle, rotationDampening * Time.deltaTime);
79.             }
80.         }
81.        
82.  
83.         // calculate the desired distance
84.         desiredDistance -= Input.GetAxis ("Mouse ScrollWheel") * Time.deltaTime * zoomRate * Mathf.Abs (desiredDistance) * speedDistance;
85.         desiredDistance = Mathf.Clamp (desiredDistance, minDistance, maxDistance);
86.  
87.         yDeg = ClampAngle(yDeg, yMinLimit, yMaxLimit);
88.        
89.         // set camera rotation
90.         Quaternion rotation = Quaternion.Euler(yDeg, xDeg, 0);
91.         correctedDistance = desiredDistance;
92.  
93.         // calculate desired camera position
94.         vTargetOffset = new Vector3 (0, -targetHeight, 0);
95.         Vector3 position = target.position - (rotation * Vector3.forward * desiredDistance + vTargetOffset);
96.  
97.         // check for collision using the true target's desired registration point as set by user using height
98.         RaycastHit collisionHit;
99.         Vector3 trueTargetPosition = new Vector3(target.position.x, target.position.y, target.position.z) - vTargetOffset;
100.  
101.         // if there was a collision, correct the camera position and calculate the corrected distance
102.         bool isCorrected = false;
103.         if (Physics.Linecast (trueTargetPosition, position, out collisionHit, collisionLayers.value))
104.         {
105.             // calculate the distance from the original estimated position to the collision location,
106.             // subtracting out a safety "offset" distance from the object we hit.  The offset will help
107.             // keep the camera from being right on top of the surface we hit, which usually shows up as
108.             // the surface geometry getting partially clipped by the camera's front clipping plane.
109.             correctedDistance = Vector3.Distance (trueTargetPosition, collisionHit.point) - offsetFromWall;
110.             isCorrected = true;
111.         }
112.  
113.         // For smoothing, lerp distance only if either distance wasn't corrected, or correctedDistance is more than currentDistance
114.         currentDistance = !isCorrected || correctedDistance > currentDistance ? Mathf.Lerp (currentDistance, correctedDistance, Time.deltaTime * zoomDampening) : correctedDistance;
115.  
116.         // keep within legal limits
117.         currentDistance = Mathf.Clamp (currentDistance, minDistance, maxDistance);
118.  
119.         // recalculate position based on the new currentDistance
120.         position = target.position - (rotation * Vector3.forward * currentDistance + vTargetOffset);
121.        
122.         transform.rotation = rotation;
123.         transform.position = position;
124.     }
125.  
126.     private static float ClampAngle (float angle, float min, float max)
127.     {
128.         if (angle < -360)
129.             angle += 360;
130.         if (angle > 360)
131.             angle -= 360;
132.         return Mathf.Clamp (angle, min, max);
133.     }
134. }
135.  
136.  

 

Thanks for the tip sandolkakos, I had a feeling that it had to do with the pivot point. I will have to try your tip and see if it helps. Thanks again!

 

and dont forgot of Collision Layers.
Unselect the Player Layer.

 

Hey sandolkakos, the issue with my code was definitely the collision layers. So that problem is fixed now, but I have a new one. I am using your code that you provided, and im trying to convert it to javascript but im getting weird behavior issues.

Whenever the camera is colliding with something, it bounces back and forth every frame, and I cannot figure out what I have done wrong.

I am assuming a value is not getting set correctly between frames and it keeps trying to reset to the desiredDistance?

Here is my function, it gets called from the LateUpdate() function:

Code (csharp):

1.  
2. function Start()
3. {
4.     var angles = transform.eulerAngles;
5.     cameraAngleX = angles.y;
6.     cameraAngleY = angles.x;
7.  
8.     // Make the rigid body not change rotation
9.     if (rigidbody) rigidbody.freezeRotation = true;
10.    
11.     // Camera stuff added
12.     currentDistance = cameraDistance;
13.     desiredDistance = cameraDistance;
14.     correctedDistance = cameraDistance;
15. }
16.  
17. // CAMERA VARIABLES
18. var playerCamera : Transform;
19. var mask : LayerMask = -1;
20. private var cameraSmoothing = 5;
21. private var cameraHeight = 0.7;
22. private var cameraDistance = 1.5;
23. private var cameraMaxDistance = 10;
24. private var cameraMinDistance = 0.5;
25. private private private var cameraXSpeed = 250.0;
26. private var cameraYSpeed = 120.0;
27. private var cameraYMinLimit = -40;
28. private var cameraYMaxLimit = 80;
29. private var cameraZoomRate = 40;
30. private var cameraRotationDampening = 3.0;
31. private var cameraAngleX = 0.0;
32. private var cameraAngleY = 0.0;
33. private var currentDistance = 0.0;
34. private var desiredDistance = 0.0;
35. private var correctedDistance = 0.0;
36. private var cameraSpeedDistance = 2;
37.  
38. function CameraCalculation()
39. {
40.     // If no camera is selected, don't do camera calculations
41.     if(!playerCamera)
42.         return;
43.    
44.     // If either mouse buttons are down, let them govern camera position
45.     if (Input.GetMouseButton(0) || (Input.GetMouseButton(1)))
46.     {
47.         cameraAngleX += Input.GetAxis("Mouse X") * cameraXSpeed * 0.02;
48.         cameraAngleY -= Input.GetAxis("Mouse Y") * cameraYSpeed * 0.02;
49.     }
50.    
51.     // otherwise, ease behind the target if any of the directional keys are pressed
52.     else if(Input.GetAxis("Vertical") || Input.GetAxis("Horizontal"))
53.     {
54.         var targetRotationAngle = transform.eulerAngles.y;
55.         var currentRotationAngle = playerCamera.eulerAngles.y;
56.         cameraAngleX = Mathf.LerpAngle(currentRotationAngle, targetRotationAngle, cameraRotationDampening * Time.deltaTime);
57.     }
58.  
59.     desiredDistance -= (Input.GetAxis("Mouse ScrollWheel") * Time.deltaTime) * cameraZoomRate * Mathf.Abs(desiredDistance) * cameraSpeedDistance;
60.     desiredDistance = Mathf.Clamp(desiredDistance, cameraMinDistance, cameraMaxDistance);
61.    
62.     cameraAngleY = ClampAngle(cameraAngleY, cameraYMinLimit, cameraYMaxLimit);
63.    
64.     // ROTATE CAMERA:
65.     var rotation:Quaternion = Quaternion.Euler(cameraAngleY, cameraAngleX, 0);
66.     correctedDistance = desiredDistance;
67.    
68.     // POSITION CAMERA:
69.     var position = transform.position - (rotation * Vector3.forward * desiredDistance + Vector3(0,-cameraHeight,0));
70.    
71.     // IS VIEW BLOCKED?
72.     var hit : RaycastHit;
73.     var trueTransformPosition : Vector3 = transform.position - Vector3(0,-cameraHeight,0);
74.    
75.     // Cast the line to check:
76.     var isCorrected : boolean = false;
77.     if (Physics.Linecast (trueTransformPosition, playerCamera.transform.position, hit, mask))
78.     {
79.         // If so, shorten distance so camera is in front of object:
80.                
81.         // Finally, reposition the camera
82.         correctedDistance = Vector3.Distance (trueTransformPosition, hit.point) - 0.28;
83.         isCorrected = true;
84.    }
85.    
86.     // Smoothing
87.     currentDistance = !isCorrected || correctedDistance > currentDistance ? Mathf.Lerp (currentDistance, correctedDistance, Time.deltaTime * cameraSmoothing) : correctedDistance;
88.  
89.            
90.     // keep within legal limits
91.     currentDistance = Mathf.Clamp (currentDistance, cameraMinDistance, cameraMaxDistance);
92.  
93.     // recalculate position based on the new currentDistance
94.     position = transform.position - (rotation * Vector3.forward * currentDistance + Vector3(0,-cameraHeight,0));
95.  
96.     // Set the camera values
97.     playerCamera.transform.rotation = rotation;
98.     playerCamera.transform.position = position;
99. }

Any ideas as to what is causing the jumpiness?

 

sorry Fishypants, but i am still very much beginner and i still cant know how fix this problem

 

Alright, I figured it out. There error was on this line:

Code (csharp):

1. if (Physics.Linecast (trueTransformPosition, playerCamera.transform.position, hit, mask))

It was checking against the current camera position, and thats not exactly what we want, you want to check against the desired position, or more specifically the "position" variable, which is set on this line:

Code (csharp):

1. var position = transform.position - (rotation * Vector3.forward * desiredDistance + Vector3(0,-cameraHeight,0));

So when I change the code to this:

Code (csharp):

1. if (Physics.Linecast (trueTransformPosition, position, hit, mask))

It works great! Thanks for the help sandolkakos. Once I clean up my code I will post my version of the movement script if anyone is interested.

 

oh, you got it working? nice one bro, this is a cool movement system.

 

Here's the C# port of Vimalakirti's script.

I had to heavily modify the script for my own use so my sincere apologies if something here is broken.

Massive props to Vimalakirti. Cheers man.

Code (csharp):

1. using UnityEngine;
2. using System;
3.  
4. [RequireComponent(typeof(CharacterController))]
5. class Controller : MonoBehaviour
6. {
7.     //Movement Variables:
8.     private float jumpSpeed = 9.0f;
9.     private float gravity = 20.0f;
10.     private float runSpeed = 5.0f;
11.     private float walkSpeed = 1.7f;
12.     private float rotateSpeed = 150.0f;
13.     private bool grounded = false;
14.     private Vector3 moveDirection = Vector3.zero;
15.     private bool isWalking = true;
16.     private String moveStatus = "idle";
17.     private float xSpeed = 250.0f;
18.     private float ySpeed = 120.0f;
19.     private float yMinLimit = -40.0f;
20.     private float yMaxLimit = 80.0f;
21.     private float x = 0.0f;
22.     private float y = 0.0f;
23.  
24.     void Update()
25.     {
26.         if (grounded)
27.         {
28.             moveDirection = new Vector3((Input.GetMouseButton(1) ? Input.GetAxis("Horizontal") : 0), 0, Input.GetAxis("Vertical"));
29.  
30.             // if moving forward and to the side at the same time, compensate for distance
31.             // TODO: may be better way to do this?
32.             if (Input.GetMouseButton(1)  Input.GetAxis("Horizontal") != 0  Input.GetAxis("Vertical") != 0)
33.             {
34.                 moveDirection *= 0.7f;
35.             }
36.  
37.             moveDirection = transform.TransformDirection(moveDirection);
38.             moveDirection *= isWalking ? walkSpeed : runSpeed;
39.  
40.             if (moveDirection != Vector3.zero)
41.             {
42.                 moveStatus = isWalking ? "walking" : "running";
43.                 if (isWalking)
44.                 {
45.                     // invoke WALK animation here
46.                 }
47.                 else
48.                 {
49.                     // call RUN animation here
50.                 }
51.             }
52.             else
53.             {
54.                 // call IDLE animation here
55.             }
56.             // Jump!
57.             if (Input.GetButton("Jump"))
58.             {
59.                 // call JUMP animation here
60.                 moveDirection.y = jumpSpeed;
61.             }
62.  
63.             // Allow turning at anytime. Keep the character facing in the same direction as the Camera if the right mouse button is down.
64.             if (Input.GetMouseButton(1))
65.             {
66.                 transform.rotation = Quaternion.Euler(0, Camera.main.transform.eulerAngles.y, 0);
67.             }
68.             else
69.             {
70.                 transform.Rotate(0, Input.GetAxis("Horizontal") * rotateSpeed * Time.deltaTime, 0);
71.             }
72.  
73.             // Toggle walking/running with the T key
74.             if (Input.GetKeyDown("t")) isWalking = !isWalking;
75.  
76.             //Apply gravity
77.             moveDirection.y -= gravity * Time.deltaTime;
78.             //Move controller
79.             CharacterController controller = GetComponent<CharacterController>();
80.             CollisionFlags flags = controller.Move(moveDirection * Time.deltaTime);
81.             grounded = (flags  CollisionFlags.Below) != 0;
82.         }
83.     }
84. }

Code (csharp):

1. using UnityEngine;
2. using System;
3.  
4. [AddComponentMenu("Camera-Control/WoW Camera")]
5. public class MyCamera : MonoBehaviour
6. {
7.     public Transform target;
8.     public float targetHeight = 2.0f;
9.     public float distance = 2.8f;
10.     public float maxDistance = 10.0f;
11.     public float minDistance = 0.5f;
12.     public float xSpeed = 250.0f;
13.     public float ySpeed = 120.0f;
14.     public float yMinLimit = -40.0f;
15.     public float yMaxLimit = 80.0f;
16.     public float zoomRate = 20.0f;
17.     public float rotationDampening = 3.0f;
18.     private float x = 0.0f;
19.     private float y = 0.0f;
20.     public bool isTalking = false;
21.  
22.     void Start()
23.     {
24.         Vector3 angles = transform.eulerAngles;
25.         x = angles.y;
26.         y = angles.x;
27.  
28.         // Make the rigid body not change rotation
29.         if (rigidbody) rigidbody.freezeRotation = true;
30.     }
31.  
32.     void LateUpdate()
33.     {
34.         if (!target) return;
35.  
36.         // If either mouse buttons are down, let them govern camera position
37.         if (Input.GetMouseButton(0) || (Input.GetMouseButton(1)))
38.         {
39.             x += Input.GetAxis("Mouse X") * xSpeed * 0.02f;
40.             y -= Input.GetAxis("Mouse Y") * ySpeed * 0.02f;
41.         }
42.         // otherwise, ease behind the target if any of the directional keys are pressed
43.         else if (Input.GetAxis("Vertical") != 0 || Input.GetAxis("Horizontal") != 0)
44.         {
45.             float targetRotationAngle = target.eulerAngles.y;
46.             float currentRotationAngle = transform.eulerAngles.y;
47.             x = Mathf.LerpAngle(currentRotationAngle, targetRotationAngle, rotationDampening * Time.deltaTime);
48.         }
49.  
50.         distance -= (Input.GetAxis("Mouse ScrollWheel") * Time.deltaTime) * zoomRate * Mathf.Abs(distance);
51.         distance = Mathf.Clamp(distance, minDistance, maxDistance);
52.  
53.         y = ClampAngle(y, yMinLimit, yMaxLimit);
54.  
55.         // ROTATE CAMERA:
56.         Quaternion rotation = Quaternion.Euler(y, x, 0);
57.         transform.rotation = rotation;
58.  
59.         // POSITION CAMERA:
60.         Vector3 position = target.position - (rotation * Vector3.forward * distance + new Vector3(0, -targetHeight, 0));
61.         transform.position = position;
62.  
63.         // IS VIEW BLOCKED?
64.         RaycastHit hit = new RaycastHit();
65.         Vector3 trueTargetPosition = target.transform.position - new Vector3(0, -targetHeight, 0);
66.         // Cast the line to check:
67.         if (Physics.Linecast(trueTargetPosition, transform.position, out hit))
68.         {
69.             // If so, shorten distance so camera is in front of object:
70.             float tempDistance = Vector3.Distance(trueTargetPosition, hit.point) - 0.28f;
71.             // Finally, rePOSITION the CAMERA:
72.             position = target.position - (rotation * Vector3.forward * tempDistance + new Vector3(0, -targetheight, 0));
73.             transform.position = position;
74.         }
75.     }
76.  
77.     static float ClampAngle(float angle, float min, float max)
78.     {
79.         if (angle < -360) angle += 360;
80.         if (angle > 360) angle -= 360;
81.         return Mathf.Clamp(angle, min, max);
82.     }
83. }

 

I made a very simple strafing - just add before the end of the Update ( }; ) and you should be good

Now "strafemod" is a variable of the type float with an initial value of 0.0 and Strafel is your left strafe input while Strafer is your right strafe input. Replace with Input.GetKey("yourkeygoeshere") if you don't want it to be variable input keys (which I prefer because I want players to be able to modify their keyboard settings)

Code (csharp):

1. //simple strafing
2.    //now let's do the quick check if we're walking or running
3.    //walking goes here
4.    if(isWalking == true){
5.    //left strafe button is pressed -> strafe to the left
6.    if (Input.GetButton("Strafel")){
7.    strafemod = walkSpeed * Time.deltaTime;
8.    transform.Translate ((strafemod * -1), 0, 0);
9.    }
10. //right strafe button is pressed -> strafe to the right
11. if (Input.GetButton("Strafer")){
12.    strafemod = walkSpeed * Time.deltaTime;
13.    transform.Translate (strafemod, 0, 0);
14.    }
15.  
16.    }
17.    //running goes here
18.    else{
19.    //left strafe button is pressed -> strafe to the left
20. if (Input.GetButton("Strafel")){
21.    strafemod = runSpeed * Time.deltaTime;
22.    transform.Translate ((strafemod * -1), 0, 0);
23.    }
24.   //left strafe button is pressed -> strafe to the right
25. if (Input.GetButton("Strafer")){
26.    strafemod = runSpeed * Time.deltaTime;
27.    transform.Translate (strafemod, 0, 0);
28.    }  
29.    }

 

Hey did I get a chance to thank you folks?
What excellent incredible work!

Thank you so much!
Jim Cullen

 

Hi again. My strafing script from before had a fundamental flaw unfortunately - due to the nature of transform.Translation you could easily move through walls

Anyway I've compensated the problem by changing to the characterController.Move method

Code (csharp):

1.  
2.    //simple strafing
3.    //now let's do the quick check if we're walking or running
4.    //walking goes here
5.    if(isWalking == true){
6.    //left strafe button is pressed -> strafe to the left
7.    if (Input.GetButton("Strafel")){
8.   strafemod = new Vector3(1, 0, 0);
9.    strafemod = transform.TransformDirection(strafemod);
10.    controller.Move(((strafemod * walkSpeed)*-1) * Time.deltaTime);
11.    }
12. //right strafe button is pressed -> strafe to the right
13. if (Input.GetButton("Strafer")){
14.   strafemod = new Vector3(1, 0, 0);
15.    strafemod = transform.TransformDirection(strafemod);
16.    controller.Move((strafemod * walkSpeed) * Time.deltaTime);
17.    }
18.  
19.    }
20.    //running goes here
21.    else{
22.    //left strafe button is pressed -> strafe to the left
23. if (Input.GetButton("Strafel")){
24.    strafemod = new Vector3(1, 0, 0);
25.    strafemod = transform.TransformDirection(strafemod);
26.    controller.Move(((strafemod * runSpeed)*-1) * Time.deltaTime);
27.    }
28.   //left strafe button is pressed -> strafe to the right
29. if (Input.GetButton("Strafer")){
30.    strafemod = new Vector3(1, 0, 0);
31.    strafemod = transform.TransformDirection(strafemod);
32.    controller.Move((strafemod * runSpeed) * Time.deltaTime);
33.    }  
34.    }

Ok now these changes also require to change the variable strafemod from a float to Vector3.zero:

Code (csharp):

1.  
2. private var strafemod:Vector3 = Vector3.zero;

sorry for the inconvenience with the previous script

EDIT:

Another wow-style feature of the character movement is the fact that the character will be slower when moving backwards. In order to establish this I've included following variables:

Code (csharp):

1.  
2. private var bmove:boolean = false;
3. private var bspeed:float = 0.0;
4.  

The rest of the code is within our Update function:

Code (csharp):

1.  
2. //let's check if we're moving backwards
3. if(Input.GetAxis("Vertical") < 0){
4.    bmove = true;
5. }
6. else{
7.    bmove = false;
8. }
9. //now apply the slow to our movement if we're moving backwards
10. if(isWalking == true){
11.     if(bmove == true){
12. //let's check if we're already slower and keep the speed to prevent a loop
13.          if(bspeed > 0){
14.             bspeed = bspeed;
15.          }
16.          else{
17. //now we tell our variable how fast 100% is
18.          bspeed = walkSpeed;
19. //and now to notch it down to 60%
20.          walkSpeed = bspeed * 0.6;
21.          }
22.      }
23. //now if we're not moving backwards let's resume 100% speed
24.      else{
25.      if(bspeed > 0){
26.      walkSpeed = bspeed;
27.      bspeed = 0.0;
28.      }
29.    }
30. }
31. //now the same in blue for running ;)
32. else{
33. if(bmove == true){
34.          if(bspeed > 0){
35.             bspeed = bspeed;
36.          }
37.          else{
38.          bspeed = runSpeed;
39.          runSpeed = bspeed * 0.6;
40.          }
41.      }
42.      else{
43.      if(bspeed > 0){
44.      runSpeed = bspeed;
45.      bspeed = 0.0;
46.      }
47.    }
48. }
49.  
50.  

 

Wonderful thread, this has really helped me a lot!

I didn't need a WoW setup specifically, but a combination of the scripts in this thread and elsewhere have helped me create the camera system I need for my game. Special thanks to matrix211v1, Paintbrush, and Vimalakirti; what you've provided between you is nothing short of amazing. Also big thanks to Fishypants - I was pulling my hair out with the same glitch - but changing to position as you suggested worked like a charm. Thank you.

Here is my script. Not a WoW-style script but might be useful to someone. Full of comments (which unfortunately makes it look a bit bloated on here, sorry). Camera rotates around the player character using the mouse, and zooms in/out with the scrollwheel. Also repositions itself behind the player when they move and zooms closer when colliding with walls. Place this script on your camera.

Code (csharp):

1. // the target for the camera to orbit around
2. var target : Transform;
3.  
4. // initial distance between the camera and the target
5. var distance = 5.0;
6. // min and max distance for zooming
7. var minDistance = 3.0;
8. var maxDistance = 10.0;
9. // an offset to stop the camera clipping walls
10. var offsetFromWall : float = 0.28;
11.  
12. // the speed at which the scrollwheel zooms in/out
13. var zoomRate = 20;
14.  
15. // some internal variables to calculate distances
16. private var currentDistance : float;
17. private var desiredDistance : float;
18. private var correctedDistance : float;
19.  
20. // speed of camera rotation around the object in both axes and smoothing for rotation
21. var xSpeed : float = 200.0;
22. var ySpeed : float = 200.0;
23. var rotationDampening : float = 3.0;
24.  
25. // the min and max rotation limits of the camera in the y-axis (up and over the object) and smoothing for zooming
26. var yMinLimit : int = 0;
27. var yMaxLimit : int = 80;
28. var zoomDampening : float = 5.0;
29.  
30. // variables to store the rotation of the camera
31. private var x  : float = 0.0;
32. private var y : float = 0.0;
33.  
34.  
35. // adds a menu option to attach this script via the Component Menu
36. @script AddComponentMenu("Camera-Control/Mouse Orbit")
37.  
38.  
39. function Start () {
40.     // store the initial rotation of the camera on the x and y axes
41.     var angles = transform.eulerAngles;
42.     x = angles.y;
43.     y = angles.x;
44.  
45.     // set zoom distances to the value of the initial distance
46.     currentDistance = distance;
47.     desiredDistance = distance;
48.     correctedDistance = distance;
49.    
50.     // Make the rigid body (if there is one) not change rotation
51.     if (rigidbody) {
52.         rigidbody.freezeRotation = true;
53.     }
54. }
55.  
56. // LateUpdate is called every frame after all other updates have happened
57. //(preferable for camera follows since all objects should have already moved)
58. function LateUpdate () {
59.    
60.     // if a target has been assigned (drag and drop one in the editor)
61.     if (target) {
62.         // if there is input on the vertical or horizontal axes (default is arrow keys and wasd)
63.         if(Input.GetAxis("Vertical") || Input.GetAxis("Horizontal")) {
64.             // store the current y-axis rotation of the target and the camera
65.             var targetRotationAngle = target.eulerAngles.y;
66.             var currentRotationAngle = transform.eulerAngles.y;
67.             // interpolate between the current y-axis rotation and the target y-axis rotation over time
68.             // setting the changing value to the x-axis rotation so the camera rotates around behind the PC
69.             x = Mathf.LerpAngle(currentRotationAngle, targetRotationAngle, rotationDampening * Time.deltaTime);
70.            
71.         // if there is no input from the vertical/horizontal axes (we are not moving)
72.         } else {
73.             // allow the player to rotate the camera using the mouse by updating the camera's
74.             // x/y rotation values based on the mouse position
75.             x += Input.GetAxis("Mouse X") * xSpeed * 0.02;
76.             y -= Input.GetAxis("Mouse Y") * ySpeed * 0.02;
77.  
78.         }
79.        
80.            
81.         // set the y-axis rotation value based on the result of the ClampAngle function
82.         y = ClampAngle(y, yMinLimit, yMaxLimit);
83.        
84.         // store the camera's rotation
85.         var rotation = Quaternion.Euler(y, x, 0);
86.        
87.        
88.         // convert input from the scrollwheel into zooming between the min/max distance ranges
89.         desiredDistance -= Input.GetAxis ("Mouse ScrollWheel") * Time.deltaTime * zoomRate * Mathf.Abs (desiredDistance);
90.         desiredDistance = Mathf.Clamp (desiredDistance, minDistance, maxDistance);
91.         correctedDistance = desiredDistance;
92.        
93.         // store the camer's position
94.         var position = target.position - (rotation * Vector3.forward * desiredDistance);
95.        
96.         // a variable to hold a reference to raycast collision objects
97.         var hit : RaycastHit;
98.         // a variable to hold a flag so we know if we have already corrected the camera's position
99.         var isCorrected : boolean = false;
100.         // if a ray between the target and the desired position hits something then their must be something blocking the line of sight
101.         if (Physics.Linecast (target.position, position, hit)) {
102.                 // shorten the distance between the camera and the target using the distance to the wall
103.                 // minus an offset to prevent clipping
104.                 correctedDistance = Vector3.Distance (target.position, hit.point) - offsetFromWall;
105.                 // we have corrected the camera's position
106.                 isCorrected = true;
107.         }
108.  
109.         // if we haven't corrected the camera's position or the new distance is greater than the current distance
110.         if(!isCorrected || correctedDistance > currentDistance){
111.         // interpolate the distance of the camera from the target between the current distance and the corrected distances
112.         // (ie. in front of the wall that is blocking our view)
113.                
114.             currentDistance = Mathf.Lerp (currentDistance, correctedDistance, Time.deltaTime * zoomDampening);
115.            
116.         }
117.         // set our current distance to this new distance
118.         currentDistance = correctedDistance;
119.            
120.         // clamp this value between the minimum and maximum distance settings
121.         currentDistance = Mathf.Clamp(currentDistance, minDistance, maxDistance);
122.  
123.         // store the new position
124.         position = target.position - (rotation * Vector3.forward * currentDistance);
125.    
126.        
127.         // set the current rotation and position of the camera to the new values to make it move
128.         transform.rotation = rotation;
129.         transform.position = position;
130.     }
131. }  
132.        
133.  
134. // keeps the value of the y-axis rotation within 360 degrees (it would cause an error otherwise)
135. // and within the minimum and maximum limits previously defined
136. static function ClampAngle (angle : float, min : float, max : float) {
137.     if (angle < -360)
138.         angle += 360;
139.     if (angle > 360)
140.         angle -= 360;
141.     return Mathf.Clamp (angle, min, max);
142. }

 

@cilmeron

Could you please post the whole script?

Thanks

 

Here's the complete move script I'm currently using:

I've also included an if-routine for the case the character is swimming.

Code (csharp):

1.  
2. // Movement Variables:
3. var jumpSpeed:float = 9.0;
4. private var gravity:float = 20.0;
5. static var runSpeed:float = 4.0;
6. static var swimSpeed:float = 2.0;
7. static var walkSpeed:float = 1.7;
8. static var runSpeedsave = 4.0;
9. static var walkSpeedsave = 1.7;
10. static var curSpeed:float = 0.0;
11. private var rotateSpeed:float = 150.0;
12. private var grounded:boolean = false;
13. private var moveDirection:Vector3 = Vector3.zero;
14. static var isWalking:boolean = false;
15. private var moveStatus:String = "idle";
16. private var xSpeed = 250.0;
17. private var ySpeed = 120.0;
18. private var yMinLimit = -40;
19. private var yMaxLimit = 80;
20. private var x = 0.0;
21. private var y = 0.0;
22. static var ddistance:float = 0.0;
23. static var strafemod:Vector3 = Vector3.zero;
24. static var strafing = false;
25. static var animationspeed = 1.0;
26. var hit : RaycastHit;
27. static var isSwimming = false;
28. static var bmove = false;
29. static var bSpeed = 0.0;
30. //
31. //UPDATE
32. //
33.    
34. function Update ()
35. //check if we fell down the world and teleport to a specific location
36. {
37. if(transform.position.y < -200)
38.     {
39.         transform.position.y = 16.07609;
40.         transform.position.x = 579.2826;
41.         transform.position.z = 130.8261;
42.     }
43.  
44. //Move controller
45. var controller:CharacterController = GetComponent(CharacterController);
46. var flags = controller.Move(moveDirection * Time.deltaTime);
47. grounded = (flags  CollisionFlags.Below) != 0; 
48.  
49. //check if we're moving backwards
50.    if(Input.GetAxis("Vertical") < 0){
51.    bmove = true;
52.    }
53.    else{
54.    bmove = false;
55.    }
56. //check if we're swimming
57. if(isSwimming == true){
58. swimSpeed = runSpeed/2;
59.    //reduce speed when moving backwards
60.      if(bmove == true){
61.          if(bSpeed > 0){
62.      bSpeed = bSpeed;
63.      }
64.      else{
65.      bSpeed = swimSpeed;
66.      swimSpeed = bSpeed * 0.6;
67.      }
68.      }
69.    else{
70.      if(bSpeed > 0){
71.      swimSpeed = bSpeed;
72.      bSpeed = 0.0;
73.      }
74.      }
75.        
76.       moveDirection = new Vector3((Input.GetMouseButton(1) ? Input.GetAxis("Horizontal") : 0),0,Input.GetAxis("Vertical"));
77.       if(Input.GetMouseButton(1)  Input.GetAxis("Vertical")  Input.GetAxis("Horizontal")) {
78.          moveDirection *= .7;
79.          }
80.     animationspeed = runSpeed/4;
81.     moveDirection = transform.TransformDirection(moveDirection);
82.     moveDirection *= swimSpeed;
83.        
84.      moveStatus = "swim_idle";
85.       if(moveDirection != Vector3.zero) {
86.         moveStatus = "swimming";
87. //invoke swim animation here        
88. }
89.       else {
90. //swim idle animation
91.       }
92.       // Jump (or rather dive upwards)!
93.       if(Input.GetButton("Jump"))
94.       {
95.          // call JUMP animation here
96.          moveDirection.y = swimSpeed*1.6;
97.       }
98.    
99.    // Allow turning at anytime. Keep the character facing in the same direction as the Camera if the right mouse button is down.
100.    if(Input.GetMouseButton(1)) {
101.       transform.rotation = Quaternion.Euler(Camera.main.transform.eulerAngles.x,Camera.main.transform.eulerAngles.y,0);
102.    }
103.    else {
104.      transform.Rotate(0,Input.GetAxis("Horizontal") * rotateSpeed * Time.deltaTime, 0);
105.    }
106.    //simple strafing
107.    //now let's do the quick check if we're walking or running
108.    //walking goes here
109.    //left strafe button is pressed -> strafe to the left
110.    if (Input.GetButton("Strafel")){
111.    strafemod = new Vector3(-1, 0, 0);
112.    strafemod = transform.TransformDirection(strafemod);
113.    strafemod = swimSpeed * strafemod;
114.    controller.Move (strafemod * Time.deltaTime);
115.    }
116. //right strafe button is pressed -> strafe to the right
117. if (Input.GetButton("Strafer")){
118.    strafemod = new Vector3(1, 0, 0);
119.    strafemod = transform.TransformDirection(strafemod);
120.    strafemod = swimSpeed * strafemod;
121.    controller.Move (strafemod * Time.deltaTime);
122.    }
123.    }
124.    else{
125.  
126. //check if we're moving
127.    if(Input.GetAxis("Vertical") != 0 || Input.GetAxis("Horizontal") != 0 || Input.GetButton("Strafel") || Input.GetButton("Strafer")){
128.    if(isWalking == true){
129.    curSpeed = walkSpeed;
130.    }
131.    else{
132.    curSpeed = runSpeed;
133.    }
134.    }
135.    else{
136.    curSpeed = 0.0;
137.  
138. //since the backward slowing can have some permanent effects to our runSpeed and walkSpeed (i.e. the speed will stick to 60%) here's some failsave code making use of the run/walk Speedsave variables
139.      
140.    if(runSpeed < runSpeedsave){
141.    runSpeed = runSpeedsave;
142.    }
143.    
144.  
145.    if(walkSpeed < walkSpeedsave){
146.    walkSpeed = walkSpeedsave;
147.    }
148.    }
149.  
150.    
151.    //reduce speed when moving backwards
152.    if(isWalking == true){
153.    
154.    if(bmove == true){
155.         if(bSpeed > 0){
156.         bSpeed = bSpeed;
157.         }
158.         else{
159.         bSpeed = walkSpeed;
160.         walkSpeed = bSpeed * 0.6;
161.         }
162.                             }
163.    else{
164.         if(bSpeed > 0){
165.         walkSpeed = bSpeed;
166.         bSpeed = 0.0;
167.         }
168.     }
169.     }
170.    else{
171.     if(bmove == true){
172.    if(bSpeed > 0){
173.    bSpeed = bSpeed;
174.    }
175.    else{
176.    bSpeed = runSpeed;
177.    runSpeed = bSpeed * 0.6;
178.    }
179.    }
180.    else{
181.    if(bSpeed > 0){
182.    runSpeed = bSpeed;
183.    bSpeed = 0.0;
184.    }
185.    }
186.    }
187.    
188.    //check if we're moving - if we're moving track distance and save to ddistance
189.    if(curSpeed > 0){
190.    ddistance = ddistance + (curSpeed * Time.deltaTime);
191.    }
192.    //
193.    // Only allow movement and jumps while -----------------  GROUNDED -------------
194.    
195.    if(grounded) {
196.    moveDirection = new Vector3((Input.GetMouseButton(1) ? Input.GetAxis("Horizontal") : 0),0,Input.GetAxis("Vertical"));
197.       if(Input.GetMouseButton(1)  Input.GetAxis("Vertical")  Input.GetAxis("Horizontal")) {
198.          moveDirection *= .7;
199.          }
200.     animationspeed = runSpeed/4;
201.     moveDirection = transform.TransformDirection(moveDirection);
202.       moveDirection *= isWalking ? walkSpeed : runSpeed;
203.        
204.       moveStatus = "idle";
205.       if(moveDirection != Vector3.zero) {
206.          moveStatus = isWalking ? "walking" : "running";
207.          if (isWalking){
208.            // invoke WALK animation here
209.          } else {
210.     // call RUN animation here
211.          }
212.       } else {
213.         // call IDLE animation here
214.       }
215.       // Jump!
216.       if(Input.GetButton("Jump"))
217.       {
218.          // call JUMP animation here
219.          moveDirection.y = jumpSpeed;
220.       }
221.     }                  
222.     // END "IS GROUNDED"
223.    
224.    // Allow turning at anytime. Keep the character facing in the same direction as the Camera if the right mouse button is down.
225.    if(Input.GetMouseButton(1)) {
226.       transform.rotation = Quaternion.Euler(0,Camera.main.transform.eulerAngles.y,0);
227.    }
228.    else {
229.      transform.Rotate(0,Input.GetAxis("Horizontal") * rotateSpeed * Time.deltaTime, 0);
230.    }
231.    
232.    // Toggle walking/running with the walk/run key
233.    if(Input.GetButtonDown("walk"))
234.          isWalking = !isWalking;
235.        
236.    //Apply gravity
237.    moveDirection.y -= gravity * Time.deltaTime;
238.    //Move controller
239.    //var controller:CharacterController = GetComponent(CharacterController);
240.    //var flags = controller.Move(moveDirection * Time.deltaTime);
241.    grounded = (flags  CollisionFlags.Below) != 0;
242.    
243.    //simple strafing
244.    //now let's do the quick check if we're walking or running
245.    //walking goes here
246.    if(isWalking == true){
247.    //left strafe button is pressed -> strafe to the left
248.    if (Input.GetButton("Strafel")){
249.    strafemod = new Vector3(-1, 0, 0);
250.    strafemod = transform.TransformDirection(strafemod);
251.    strafemod = walkSpeed * strafemod;
252.    controller.Move (strafemod * Time.deltaTime);
253.    }
254. //right strafe button is pressed -> strafe to the right
255. if (Input.GetButton("Strafer")){
256.    strafemod = new Vector3(1, 0, 0);
257.    strafemod = transform.TransformDirection(strafemod);
258.    strafemod = walkSpeed * strafemod;
259.    controller.Move (strafemod * Time.deltaTime);
260.    }
261.  
262.    }
263.    //running goes here
264.    else{
265.    //left strafe button is pressed -> strafe to the left
266. if (Input.GetButton("Strafel")){
267.    strafemod = new Vector3(-1, 0, 0);
268.    strafemod = transform.TransformDirection(strafemod);
269.    strafemod = runSpeed * strafemod;
270.    controller.Move (strafemod * Time.deltaTime);
271.    }
272.   //left strafe button is pressed -> strafe to the right
273. if (Input.GetButton("Strafer")){
274.    strafemod = new Vector3(1, 0, 0);
275.    strafemod = transform.TransformDirection(strafemod);
276.    strafemod = runSpeed * strafemod;
277.    controller.Move (strafemod * Time.deltaTime);
278.    }  
279.    }
280.    }
281.    };
282.    
283.    static function ClampAngle (angle : float, min : float, max : float) {
284.    if (angle < -360)
285.       angle += 360;
286.    if (angle > 360)
287.       angle -= 360;
288.    return Mathf.Clamp (angle, min, max);
289. }
290.  
291.  
292. // -------------------------------------------------------------------------------------------------------------
293. // ----------------------------------------------------------- END UPDATE  --------------------------------
294. // -------------------------------------------------------------------------------------------------------------
295.  
296. @script RequireComponent(CharacterController)
297.  

Now to find out if the character is swimming I created some water element (i.e. a cube) with a mesh Collider and isTrigger on. I then applied this script to the "water":

Code (csharp):

1.  
2.      
3. function OnTriggerEnter  (other : Collider) {
4. if (other.gameObject.tag == "Player") {
5. move.isSwimming = true;
6. }
7. }
8.  
9. function OnTriggerExit  (other : Collider) {
10. if (other.gameObject.tag == "Player") {
11. move.isSwimming = false;
12. }
13. }

Oh yeah and my camera script - which is pretty much what has been posted on here already but includes a passive mode when pressing the camera button (has to be defined in the Input settings -> the same goes for walk/strafelel and strafer)

Code (csharp):

1.  
2. var target : Transform;
3. var targetHeight = 2.0;
4. var distance = 2.8;
5. var maxDistance = 10;
6. var minDistance = 0.5;
7. var xSpeed = 250.0;
8. var ySpeed = 120.0;
9. var yMinLimit = -40;
10. var yMaxLimit = 80;
11. static var camactive = true;
12. var zoomRate = 20;
13. var rotationDampening = 3.0;
14. private var x = 0.0;
15. private var y = 0.0;
16. static var underwater:boolean = false;
17. var isTalking:boolean = false;
18.  
19. @script AddComponentMenu("Camera-Control/WoW Camera")
20.  
21. function Start () {
22.     var angles = transform.eulerAngles;
23.     x = angles.y;
24.     y = angles.x;
25.  
26.    // Make the rigid body not change rotation
27.       if (rigidbody)
28.       rigidbody.freezeRotation = true;
29. }
30.  
31. function Update() {
32. if(underwater == true)
33.    {
34.       color = Color (56.0, 166.0, 198.0, 122.0);        
35.       RenderSettings.fogColor = color;
36.       RenderSettings.fogDensity = 0.1;
37.    }
38.    
39.    
40.    
41.    }
42.  
43. function LateUpdate () {
44.    if(!target)
45.       return;
46.    
47.    if (Input.GetButtonDown("Camera")){
48.     camactive = !camactive;
49.    }
50.    // If either mouse buttons are down, let them govern camera position
51.    
52.    if(camactive == true){
53.    if (Input.GetMouseButton(0) || (Input.GetMouseButton(1))){
54.    x += Input.GetAxis("Mouse X") * xSpeed * 0.02;
55.    y -= Input.GetAxis("Mouse Y") * ySpeed * 0.02;
56.    
57.    
58.    // otherwise, ease behind the target if any of the directional keys are pressed
59.    } else if(Input.GetAxis("Vertical") || Input.GetAxis("Horizontal")) {
60.       var targetRotationAngle = target.eulerAngles.y;
61.       var currentRotationAngle = transform.eulerAngles.y;
62.       x = Mathf.LerpAngle(currentRotationAngle, targetRotationAngle, rotationDampening * Time.deltaTime);
63.      
64.     }
65.     }
66.     else{
67.     if (Input.GetMouseButton(0) || (Input.GetMouseButton(1))){
68.    x += Input.GetAxis("Mouse X") * xSpeed * 0.02;
69.    y -= Input.GetAxis("Mouse Y") * ySpeed * 0.02;
70.    
71.    
72.    // otherwise, ease behind the target if any of the directional keys are pressed
73.    }
74.    }
75.    
76.      
77.  
78.    distance -= (Input.GetAxis("Mouse ScrollWheel") * Time.deltaTime) * zoomRate * Mathf.Abs(distance);
79.    distance = Mathf.Clamp(distance, minDistance, maxDistance);
80.    
81.    y = ClampAngle(y, yMinLimit, yMaxLimit);
82.    
83.   // ROTATE CAMERA:
84.    var rotation:Quaternion = Quaternion.Euler(y, x, 0);
85.    transform.rotation = rotation;
86.    
87.    // POSITION CAMERA:
88.    var position = target.position - (rotation * Vector3.forward * distance + Vector3(0,-targetHeight,0));
89.    transform.position = position;
90.    
91.    // IS VIEW BLOCKED?
92.     var hit : RaycastHit;
93.     var trueTargetPosition : Vector3 = target.transform.position - Vector3(0,-targetHeight,0);
94.    // Cast the line to check:
95.     if (Physics.Linecast (trueTargetPosition, transform.position, hit)) {
96.       // If so, shorten distance so camera is in front of object:
97.       var tempDistance = Vector3.Distance (trueTargetPosition, hit.point) - 0.28;
98.       // Finally, rePOSITION the CAMERA:
99.       position = target.position - (rotation * Vector3.forward * tempDistance + Vector3(0,-targetHeight,0));
100.       transform.position = position;
101.    }
102. }
103.  
104. static function ClampAngle (angle : float, min : float, max : float) {
105.    if (angle < -360)
106.       angle += 360;
107.    if (angle > 360)
108.       angle -= 360;
109.    return Mathf.Clamp (angle, min, max);
110.    
111. }

 

Thank you very much.

It works perfectly.

But I get an error message
NullReferenceException: Object reference not set to an instance of an object
CharControllerBeta.Update () (at Assets\CharControllerBeta.js:100)

and Line 255 (Strafel and Strafer).
Both works fine Ive also createt 2 inputs for them, but the error still exists.

Another question is: how to change between walk and run?

Thanks again

 

this line is responsible for the change between walking and running:

Code (csharp):

1. if(Input.GetButtonDown("walk"))
2.          isWalking = !isWalking;

So you have to set up an input for "walk".

As for the error message - what code do you have on line 100?

 

On line 100:

transform.rotation = Quaternion.Euler(0,Camera.main.transform.eulerAngles.y,0);


on the other line:

strafemod = transform.TransformDirection(strafemod);

Both are "NullReferenceException: Object reference not set to an instance of an object"

 

Do you mind posting the whole script? The NullReferenceException usually only occurs when an object doesn't have any value which doesn't seem possible from/on the lines you posted oO

 

Its the same script youve posted above.

Ive changed nothing^^

 

The code below takes Vima's "camera correction on idle" snippet into consideration, while also providing a fix to the camera "fall-through" where you're able to see beneath terrain. I've not tested it with other 3D objects in presence though. Enjoy.

Quick edit: I've also rid of the LMB usage to move the camera, it now only uses the RMB.

Code (csharp):

1. var target : Transform;
2. var distance = 10.0;
3.  
4. var xSpeed = 250.0;
5. var ySpeed = 120.0;
6.  
7. var yMinLimit = -20;
8. var yMaxLimit = 80;
9.  
10. var zoomRate = 20;
11.  
12. private var x = 0.0;
13. private var y = 0.0;
14.  
15. @script AddComponentMenu("Camera-Control/Mouse Orbit")
16.  
17. function Start ()
18. {
19.     var angles = transform.eulerAngles;
20.     x = angles.y;
21.     y = angles.x;
22.  
23.     if (rigidbody)
24.         rigidbody.freezeRotation = true;
25. }
26.  
27. function LateUpdate ()
28. {
29.     CameraHandle();
30. }
31.  
32. function CameraHandle()
33. {
34.     if(target)
35.     {
36.         var hit : RaycastHit;
37.        
38.         if (Input.GetMouseButton(1))
39.         {
40.             x += Input.GetAxis("Mouse X") * xSpeed * 0.02;
41.             y -= Input.GetAxis("Mouse Y") * ySpeed * 0.02;
42.         }
43.         else if(Input.GetAxis("Vertical") || Input.GetAxis("Horizontal"))
44.             x = Mathf.LerpAngle(
45.                     transform.eulerAngles.y,
46.                     target.eulerAngles.y,
47.                     3.0 * Time.deltaTime);
48.        
49.         var oy = y;
50.  
51.         y = ClampAngle(y, yMinLimit, yMaxLimit);
52.  
53.         if(y == yMinLimit  
54.             oy == yMinLimit)
55.             distance +=
56.                 -(Input.GetAxis("Mouse Y") *
57.                 Time.deltaTime) *
58.                 10 *
59.                 Mathf.Abs(distance);
60.  
61.         var rotation = Quaternion.Euler(y, x, 0);
62.         var position =
63.                 rotation *
64.                 Vector3(0.0, 1.0, -distance) +
65.                 target.position;
66.  
67.         transform.rotation = rotation;
68.        
69.         if(Physics.Raycast(
70.             Vector3(position.x, position.y - 0.5, position.z),
71.             transform.forward,
72.             hit,
73.             distance)
74.             hit.rigidbody != target.rigidbody)
75.             transform.position = Vector3(hit.point.x, hit.point.y + 0.5, hit.point.z);
76.         else
77.             transform.position = position;
78.     }
79. }
80.  
81. static function ClampAngle (angle : float, min : float, max : float)
82. {
83.     if (angle < -360)
84.         angle += 360;
85.     if (angle > 360)
86.         angle -= 360;
87.  
88.     return Mathf.Clamp (angle, min, max);
89. }

 

First off, props to the people of this thread! This is a monument to the Unity Community!

I encountered a problem though... When changing the zoom to depend on mouse movement (both mouse buttons down), the zoom function became really wonky on my computer. Moving the mouse even a hair's breadth in the positive Y direction made me zoom in, while I needed to pull the mouse forcefully towards me if I wanted to zoom out.

If I pulled the mouse slowly towards me, I got no response at all, which lead me to believe the float value of axis "Mouse Y" was tiny, and didn't achieve sufficient size to affect the "distance" variable. The "distance" variable, of course, needed to be declared as a float ( ).

I've posted my modified code below, it mimics a Homeworld-style control, where the user needs to start camera movement by having the mouse cursor in "open space" (camera screen space with no interfering GUI elements).

Code (csharp):

1. //MyCamera.js
2. //Attach to main camera, drag target object (camera focus) into inspector slot
3.  
4. var target : Transform;
5. var targetHeight = 6.0;
6. var distance = 15;
7. var maxDistance = 200;
8. var minDistance = 5;
9. var xSpeed = 250.0;
10. var ySpeed = 120.0;
11. var yMinLimit = 0;
12. var yMaxLimit = 80;
13. var zoomRate = 5;
14. var rotationDampening = 3.0;
15. private var x = 0.0;
16. private var y = 0.0;
17. var isTalking:boolean = false;
18.  
19. var mouseIsDown = false;
20. var bothMouseDown = false;
21.  
22. @script AddComponentMenu("Camera-Control/WoW Camera")
23.  
24. function Start () {
25.     var angles = transform.eulerAngles;
26.     x = angles.y;
27.     y = angles.x;
28.  
29.     // Make the rigid body not change rotation
30.     if (rigidbody)
31.     rigidbody.freezeRotation = true;
32. }
33.  
34. function LateUpdate () {
35.     if(!target) {
36.         return;
37.     }
38.    
39.     var cornerX = Screen.width*0.2;
40.     var cornerY = Screen.height*0.3;
41.     var rect = Rect (cornerX, cornerY, Screen.width, Screen.height);
42.    
43.     if (GUIUtility.hotControl == 0) {
44.         // If right mouse button is pressed, govern camera position
45.         if (Input.GetMouseButtonDown(1)  Camera.main.pixelRect.Contains(Input.mousePosition)){
46.             mouseIsDown = true;
47.             Screen.lockCursor = true;
48.         }
49.        
50.         //If the mouse button is released anywhere, do not govern camera position
51.         else if (!Input.GetMouseButton(1)) {
52.             mouseIsDown = false;
53.             bothMouseDown = false;
54.             Screen.lockCursor = false;
55.         }
56.        
57.         //Check if both mouse buttons are down
58.         if (Input.GetMouseButton(0)  mouseIsDown) {
59.             bothMouseDown = true;
60.         } else {
61.             bothMouseDown = false;
62.         }
63.        
64.         //Govern camera
65.         if (mouseIsDown  !bothMouseDown) {
66.             x += Input.GetAxis("Mouse X") * xSpeed * 0.02;
67.             y -= Input.GetAxis("Mouse Y") * ySpeed * 0.02;
68.         } else if (mouseIsDown  bothMouseDown) {
69.             distance -= (Input.GetAxis("Mouse Y")*Time.deltaTime)*zoomRate*Mathf.Abs(distance);
70.             distance = Mathf.Clamp(distance, minDistance, maxDistance);
71.         }
72.     }
73.    
74.     y = ClampAngle(y, yMinLimit, yMaxLimit);
75.    
76.     // ROTATE CAMERA:
77.     var rotation:Quaternion = Quaternion.Euler(y, x, 0);
78.     transform.rotation = rotation;
79.    
80.     // POSITION CAMERA:
81.     var position = target.position - (rotation * Vector3.forward * distance + Vector3(0,-targetHeight,0));
82.     transform.position = position;
83. }
84.  
85. static function ClampAngle (angle : float, min : float, max : float) {
86.     if (angle < -360)
87.         angle += 360;
88.     if (angle > 360)
89.         angle -= 360;
90.     return Mathf.Clamp (angle, min, max);
91. }

(Edit: Corrected spelling)