fix body rotation and mouselook

Project/Assets/ML-Agents/Examples/FPS_Game/Scripts/AgentCubeMovement.cs

         public float spinAttackSpeed = 20f;
         private bool spinAttack;
 
+        public enum RotationAxes { MouseXAndY = 0, MouseX = 1, 	MouseY = 2 };
+        [Header("BODY ROTATION")]
+        public RotationAxes axes = RotationAxes.MouseXAndY;
+        public float sensitivityX = 15F;
+        public float sensitivityY = 15F;
+
+        public float minimumX = -360F;
+        public float maximumX = 360F;
+
+        public float minimumY = -60F;
+        public float maximumY = 60F;
+
+        float rotationX = 0F;
+        float rotationY = 0F;
+
+        Quaternion originalRotation;
+
         [Header("BODY ROTATION")]
         public bool MatchCameraRotation;
         //body rotation speed
             rb = GetComponent<Rigidbody>();
             groundCheck = GetComponent<AgentCubeGroundCheck>();
             rb.maxAngularVelocity = maxAngularVel;
+            originalRotation = transform.localRotation;
+
         }
 
         void Update()
         //     transform.localEulerAngles = m_Rotation;
         // }
 
-        public void Look(float rotate)
+        // public void Look(float rotate)
+        // {
+        //     if (Mathf.Abs(rotate) < 0.01)
+        //         return;
+        //     // var scaledRotateSpeed = agentRotationSpeed * Time.deltaTime;
+        //     var scaledRotateSpeed = agentRotationSpeed * Time.fixedDeltaTime;
+        //     m_Rotation.y += rotate * scaledRotateSpeed;
+        //     // m_Rotation.x = Mathf.Clamp(m_Rotation.x - rotate.y * scaledRotateSpeed, -89, 89);
+        //     transform.localEulerAngles = m_Rotation;
+        // }
+
+        public static float ClampAngle(float angle, float min, float max)
-            if (Mathf.Abs(rotate) < 0.01)
-                return;
-            // var scaledRotateSpeed = agentRotationSpeed * Time.deltaTime;
-            var scaledRotateSpeed = agentRotationSpeed * Time.fixedDeltaTime;
-            m_Rotation.y += rotate * scaledRotateSpeed;
-            // m_Rotation.x = Mathf.Clamp(m_Rotation.x - rotate.y * scaledRotateSpeed, -89, 89);
-            transform.localEulerAngles = m_Rotation;
+            if (angle < -360F)
+                angle += 360F;
+            if (angle > 360F)
+                angle -= 360F;
+            return Mathf.Clamp(angle, min, max);
+        }
+
+        public void Look(float xRot = 0, float yRot = 0)
+        {
+                // Read the mouse input axis
+                rotationX += Input.GetAxis("Mouse X") * sensitivityX;
+                rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
+                rotationX = ClampAngle(rotationX, minimumX, maximumX);
+                rotationY = ClampAngle(rotationY, minimumY, maximumY);
+
         }
 
         public bool applyStandingForce = false;
         void FixedUpdate()
         {
+
+
+            if (axes == RotationAxes.MouseXAndY)
+            {
+
+
+                Quaternion xQuaternion = Quaternion.AngleAxis(rotationX, Vector3.up);
+                Quaternion yQuaternion = Quaternion.AngleAxis(rotationY, -Vector3.right);
+
+                transform.localRotation = originalRotation * xQuaternion * yQuaternion;
+            }
+            else if (axes == RotationAxes.MouseX)
+            {
+                // rotationX += Input.GetAxis("Mouse X") * sensitivityX;
+                // rotationX = ClampAngle(rotationX, minimumX, maximumX);
+
+                Quaternion xQuaternion = Quaternion.AngleAxis(rotationX, Vector3.up);
+                transform.localRotation = originalRotation * xQuaternion;
+            }
+            else
+            {
+                // rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
+                // rotationY = ClampAngle(rotationY, minimumY, maximumY);
+
+                Quaternion yQuaternion = Quaternion.AngleAxis(-rotationY, Vector3.right);
+                transform.localRotation = originalRotation * yQuaternion;
+            }
+
+
+
+
 
 
             if (groundCheck && !groundCheck.isGrounded)

Project/Assets/ML-Agents/Examples/FPS_Game/Scripts/DodgeBallAgent.cs

         m_InputH = act[1];
         m_Rotate = act[2];
         m_ShootInput = act[3];
-        // m_CubeMovement.RotateBody(m_Rotate, m_InputV);
         m_CubeMovement.Look(m_Rotate);
         Vector3 moveDir = input.Cam.transform.TransformDirection(new Vector3(m_InputH, 0, m_InputV));
         moveDir.y = 0;

Project/Assets/ML-Agents/Examples/FPS_Game/Scripts/MouseLook.cs

+using UnityEngine;
+using System.Collections;
+
+// Script by IJM: http://answers.unity3d.com/questions/29741/mouse-look-script.html
+// Changed to fit standard C# conventions
+
+// MouseLook rotates the transform based on the mouse delta.
+// Minimum and Maximum values can be used to constrain the possible rotation
+
+// To make an FPS style character:
+// - Create a capsule.
+// - Add a rigid body to the capsule
+// - Add the MouseLook script to the capsule.
+// -> Set the mouse look to use LookX. (You want to only turn character but not tilt it)
+// - Add FPSWalker script to the capsule
+
+/// - Create a camera. Make the camera a child of the capsule. Reset it's transform.
+/// - Add a MouseLook script to the camera.
+/// -> Set the mouse look to use LookY. (You want the camera to tilt up and down like a head. The character already turns.)
+[AddComponentMenu("Camera-Control/Mouse Look")]
+public class MouseLook : MonoBehaviour {
+
+	public enum RotationAxes { MouseXAndY = 0, MouseX = 1, 	MouseY = 2 };
+	public RotationAxes axes = RotationAxes.MouseXAndY;
+	public float sensitivityX = 15F;
+	public float sensitivityY = 15F;
+
+	public float minimumX = -360F;
+	public float maximumX = 360F;
+
+	public float minimumY = -60F;
+	public float maximumY = 60F;
+
+	float rotationX = 0F;
+	float rotationY = 0F;
+
+	Quaternion originalRotation;
+
+	void FixedUpdate()
+	{
+		if (axes == RotationAxes.MouseXAndY)
+		{
+			// Read the mouse input axis
+			rotationX += Input.GetAxis("Mouse X") * sensitivityX;
+			rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
+
+			rotationX = ClampAngle(rotationX, minimumX, maximumX);
+			rotationY = ClampAngle(rotationY, minimumY, maximumY);
+
+			Quaternion xQuaternion = Quaternion.AngleAxis(rotationX, Vector3.up);
+			Quaternion yQuaternion = Quaternion.AngleAxis(rotationY, -Vector3.right);
+
+			transform.localRotation = originalRotation * xQuaternion * yQuaternion;
+		}
+		else if (axes == RotationAxes.MouseX)
+		{
+			rotationX += Input.GetAxis("Mouse X") * sensitivityX;
+			rotationX = ClampAngle(rotationX, minimumX, maximumX);
+
+			Quaternion xQuaternion = Quaternion.AngleAxis(rotationX, Vector3.up);
+			transform.localRotation = originalRotation * xQuaternion;
+		}
+		else
+		{
+			rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
+			rotationY = ClampAngle(rotationY, minimumY, maximumY);
+
+			Quaternion yQuaternion = Quaternion.AngleAxis(-rotationY, Vector3.right);
+			transform.localRotation = originalRotation * yQuaternion;
+		}
+	}
+
+	void Start()
+	{
+		// Make the rigid body not change rotation
+		// if (rigidbody)
+		// 	rigidbody.freezeRotation = true;
+		originalRotation = transform.localRotation;
+	}
+
+	public static float ClampAngle(float angle, float min, float max)
+	{
+		if (angle < -360F)
+			angle += 360F;
+		if (angle > 360F)
+			angle -= 360F;
+		return Mathf.Clamp(angle, min, max);
+	}
+}

Project/Assets/ML-Agents/Examples/FPS_Game/Scripts/MouseLook.cs.meta

+fileFormatVersion: 2
+guid: 0fd70e4a64e0a47099c75d43d086ea62
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: