AxisAgent.cs

// comment the line below if missing Lines.cs (found at http://pastebin.com/8m69iTut )
#define SHOW_AXIS_MATH
using UnityEngine;
using System.Collections;

// TODO camera zoom with mouse wheel AxisCamera
// TODO gravity source

/// <summary>
/// used for calculating and organizing 3D axis math
/// </summary>
public class Axis {
    public Vector3 forward, up, position;
    private Vector3 right;

    public void SetIdentity() {
        up = Vector3.up;
        forward = Vector3.forward;
        right = Vector3.right;
        position = Vector3.zero;
    }

    public bool Equals(Transform t) {
        return up == t.up && forward == t.forward && position == t.position;
    }

    public Axis(Axis other) {
        up = other.up;
        right = other.right;
        forward = other.forward;
        position = other.position;
    }
    public Axis() { }

    public Vector3 GetRight() {
        return right;
        //return Vector3.Cross(up, forward).normalized;
    }
#if SHOW_AXIS_MATH
    public LineRenderer DrawSimple(ref GameObject lineObj, Color c, float size) {
        const float epsilon = 0.001f;
        Vector3 u = up * size, f = forward * size;
        Vector3[] points = {
            position + u,
            position + u * epsilon,
            position + f * epsilon,
            position + f * (1 - epsilon),
            position + f,
            Vector3.zero };
        points[points.Length - 1] = Vector3.Lerp(points[3], points[0], 0.125f);
        LineRenderer lr = Lines.Make(ref lineObj, c, points, points.Length, .1f, .1f);
        return lr;
    }
    private Vector3[] thumbtack_points_base = null;
    public LineRenderer DrawThumbtack(ref GameObject lineObj, Color c, float size, float lineWidth) {
        const float epsilon = 0.001f;
        if(thumbtack_points_base == null) {
            Vector3 pstn = Vector3.zero;
            Vector3 fwrd = Vector3.forward * size;
            Vector3 rght = Vector3.right * size;
            Vector3 up__ = Vector3.up;
            float startAngle = (360.0f / 4) - (360.0f / 32);
            Vector3 v = Quaternion.AngleAxis(startAngle, up__) * fwrd;
            Lines.MakeArc(ref thumbtack_points_base, 32, up__, v, 360, pstn);
            Vector3 tip = pstn + fwrd * Mathf.Sqrt(2);
            thumbtack_points_base[0] = thumbtack_points_base[thumbtack_points_base.Length - 1];
            int m = (32 * 5 / 8) + 1;
            thumbtack_points_base[m++] = thumbtack_points_base[m] + (tip - thumbtack_points_base[m]) * (1 - epsilon);
            thumbtack_points_base[m++] = tip;
            int n = (32 * 7 / 8) + 1;
            while(n < 32) {
                thumbtack_points_base[m++] = thumbtack_points_base[n++];
            }
            Vector3 side = pstn + rght;
            thumbtack_points_base[m++] = thumbtack_points_base[m] + (side - thumbtack_points_base[m]) * (1 - epsilon);
            thumbtack_points_base[m++] = pstn + rght;
            thumbtack_points_base[m++] = pstn + rght * epsilon;
            thumbtack_points_base[m++] = pstn;
            thumbtack_points_base[m++] = pstn + up__ * size * (1 - epsilon);
            thumbtack_points_base[m++] = pstn + up__ * size;
        }
        LineRenderer lr = Lines.Make(ref lineObj, c, thumbtack_points_base, thumbtack_points_base.Length, lineWidth, lineWidth);
        lr.useWorldSpace = false;
        return lr;
    }
#endif
    public void SetFrom(Transform t) {
        position = t.position;
        up = t.up;
        forward = t.forward;
        right = t.right;
    }

    public void SetFrom(Axis t) {
        position = t.position;
        up = t.up;
        forward = t.forward;
        right = t.right;
    }

    public void WriteInto(Transform t) {
        t.position = position;
        t.rotation = Quaternion.LookRotation(forward, up);
    }

    public void Turn(float t) {
        Quaternion turn = Quaternion.AngleAxis(t, up);
        forward = turn * forward;
        right = turn * right;
    }

    public void Pitch(float p) {
        Quaternion turn = Quaternion.AngleAxis(p, right);
        forward = turn * forward;
        up = turn * up;
    }

    public Quaternion GetUpright(Vector3 nextUp) {
        Vector3 r = Vector3.Cross(forward, nextUp);
        Vector3 fwd = Vector3.Cross(nextUp, r);
        return Quaternion.LookRotation(fwd, nextUp);
    }

    public Quaternion DeltaTo(Quaternion rotation) {
        Quaternion q = Quaternion.LookRotation(this.forward, this.up);
        return rotation * Quaternion.Inverse(q);
    }

    public Quaternion UprightDelta(Vector3 nextUp) {
        return DeltaTo(GetUpright(nextUp));
    }

    public void Rotate(Quaternion rotation) {
        forward = rotation * forward;
        up = rotation * up;
        right = rotation * right;
    }

    public void SetRotation(Quaternion rotation) {
        forward = rotation * Vector3.forward;
        up = rotation * Vector3.up;
        right = rotation * Vector3.right;
    }

    public void SetUpright(Vector3 up) {
        SetRotation(GetUpright(up));
    }
}

[System.Serializable]
public struct TupleMinMax {
    public float min, max;
    public TupleMinMax(float min, float max) { this.min = min; this.max = max; }
    public float Difference(float value) {
        if(value > max) { return max - value; }
        if(value < min) { return min - value; }
        return 0;
    }
    public float Lerp(float t) { return (max - min) * t + min; }
    public float PercentageOf(float value) { return (value - min) / (max - min); }
}

public class AxisAgent : MonoBehaviour {
    /// <summary>how the body is oriented, which decides how key input creates movement impulses</summary>
    private Axis body = new Axis();
    /// <summary>how the face is oriented, which decides where the agent's head transform is looking (if there is one)</summary>
    private Axis face = new Axis();
    /// <summary>cached rigidbody of this agent</summary>
    private Rigidbody rb;

    [Tooltip("What is moved with mouse-look, and determines the direction being aimed at.\n\nRight-click to setup a controllable agent from an otherwise Empty object."),
    ContextMenuItem("Setup Standard Axis Agent", "SetStandardAgent")]
    public Transform head;
    public Camera playerCamera;
#if SHOW_AXIS_MATH
    GameObject line_body, line_head, line_stand, line_gravity, line_velocity, line_move;
#endif

    void SetStandardAgent() {
        if(head == null) {
            head = gameObject.transform.FindChild("head");
            if(head == null) {
                head = new GameObject("head").transform;
                head.position = transform.position + transform.up * 0.875f;
                head.transform.SetParent(transform);
                head.localRotation = Quaternion.identity;
            }
        }
        if(playerCamera == null) {
            Transform t = head.FindChild("camera");
            playerCamera = (t != null) ? t.GetComponent<Camera>() : null;
            if(playerCamera == null) {
                playerCamera = new GameObject("camera").AddComponent<Camera>();
                playerCamera.transform.SetParent(head);
                playerCamera.transform.localPosition = new Vector3(0, 5, -10);
                playerCamera.transform.localRotation = Quaternion.Euler(25, 0, 0);
            }
        }
        Collider col = GetComponent<Collider>();
        if(col == null) {
            CapsuleCollider cap = gameObject.AddComponent<CapsuleCollider>();
            cap.height = 2;
            cap.radius = 0.5f;
        }
        rb = GetComponent<Rigidbody>();
        if(rb == null) {
            rb = gameObject.AddComponent<Rigidbody>();
        }
    }

    [System.Serializable]
    public struct Gravity {
        [SerializeField, Tooltip("How strong the gravity force is")]
        private float force;
        [SerializeField, Tooltip("The direction of the gravity force")]
        private Vector3 direction;
        private Vector3 calculatedForce;

        public Gravity(float force, Vector3 dir) {
            this.force = force; this.direction = dir; this.calculatedForce = force*dir; }
        public Vector3 GetDirection() { return direction; }
        public void SetDirection(Vector3 dir) { direction = dir; Refresh(); }
        public float GetForce() { return force; }
        public void SetForce(float force) { force = this.force; Refresh(); }
        public Vector3 Force() { return calculatedForce; }
        public void Negate() { calculatedForce = Vector3.zero; }
        public void Refresh() { calculatedForce = force * direction; }

        public Vector3 FixedUpdate(Rigidbody rb) { Vector3 v; rb.AddForce(v = Force()); return v; }
    }
    public Gravity gravity = new Gravity(20, Vector3.down);

    [System.Serializable]
    /// <summary>a system opposing gravity that allows an agent to hover very slightly over the ground, and move without friction</summary>
    public class Stand {
        [SerializeField, Tooltip("How far from the center (in the gravity direction) the standing volume goes")]
        private float distance = 1;
        [SerializeField, Tooltip("The radius of the standing volume")]
        private float radius = .375f;
        [Tooltip("If non-null, this transform's position will be set to the location where the standing is centered.\n\nSet to a sphere with the radius above to visualize the standing volume.")]
        public Transform marker;

        /// <summary>the actual spot being stood on</summary>
        private Vector3 groundContact;
        /// <summary>how the ground is sloped in 3D space</summary>
        private Vector3 surfaceNormal = Vector3.up;
        /// <summary>a 1D value describing how the ground is sloped. used to limit standing force</summary>
        private float surfaceAngle;
        /// <summary>used to keep the standing volume from pushing fully out of the ground. keeping the standing volume slightly overlapping helps verify that the agent is still standing.</summary>
        private float standRadiusEpsilon = 1 / 128.0f;
        /// <summary>used as fast adjustment to position using the physics system (without directly setting transform.position)</summary></summary>
        private Vector3 oneTimeForce;
        /// true if an adjustment to position needs to be made</summary>
        private bool usingOneTimeForce = false;
        /// <summary>true if standing volume is on the ground</summary>
        private bool isOnGround = true;
        [SerializeField, Tooltip("If true, will automatically match motion of transform being stood on")]
        private bool becomeParentedToPlatform = true;
        /// <summary>the actual transform being stood on</summary>
        Transform stoodOn = null;
        /// <summary>the velocity of the transform being stood on</summary>
        private Vector3 stoodOnVelocity;
        /// <summary>axis (position and rotation) of the transform being stood on</summary>
        Axis parentTransform = new Axis();
        /// <summary>the physics calculation done last frame to keep up with the stood-on transform</summary>
        Vector3 lastPlatformMove;

        public bool IsOnGround() { return isOnGround; }
        public void SetOnGround(bool onGround) { isOnGround = onGround; }
        public float GetSurfaceAngle() { return surfaceAngle; }
        public Vector3 GetSurfaceNormal() { return surfaceNormal; }
        public Vector3 GetGroundContact() { return groundContact; }

        /// <param name="a"></param>
        /// <returns>force to apply to a Rigidbody, using AddForce</returns>
        public Vector3 Force(AxisAgent a, ref Gravity g) {
            Vector3 force = Vector3.zero;
            if(usingOneTimeForce) {
                usingOneTimeForce = false;
                force -= oneTimeForce;
            }
            // if non-rigid-body parent has moved
            if(becomeParentedToPlatform && stoodOn != null && !parentTransform.Equals(stoodOn)) {
                a.rb.AddForce(-lastPlatformMove);
                stoodOnVelocity = stoodOn.position - parentTransform.position;
                lastPlatformMove = stoodOnVelocity / Time.deltaTime;
                parentTransform.SetFrom(stoodOn);
                a.rb.AddForce(lastPlatformMove);
                a.transform.position = a.transform.position + stoodOnVelocity;
            }
            Vector3 standingDirection = -g.GetDirection();
            Ray ray = new Ray(a.transform.position, -standingDirection);
            RaycastHit hitInfo = new RaycastHit();
            a.GetComponent<Collider>().enabled = false;
            if(!a.jumping.IsJumping() && Physics.SphereCast(ray, radius, out hitInfo, distance) && hitInfo.distance <= distance) {
                groundContact = hitInfo.point;
                surfaceNormal = hitInfo.normal;
                surfaceAngle = Vector3.Angle(standingDirection, surfaceNormal);
                if(Vector3.Dot(a.body.forward, surfaceNormal) > 0) {
                    surfaceAngle *= -1;
                }
                Vector3 centerOfFoot = a.transform.position - standingDirection * distance;
                if(marker != null) {
                    marker.position = centerOfFoot;
                }
                float dist = Vector3.Distance(groundContact, centerOfFoot);
                float groundOverlap = radius - dist;
                if(groundOverlap > 0) {
                    // instead of setting the position, set the force needed to clip out, then remove that force next frame.
                    usingOneTimeForce = true;
                    oneTimeForce = (surfaceNormal * (groundOverlap - standRadiusEpsilon)) / (Time.deltaTime*Time.deltaTime);
                    force += oneTimeForce;
                }
                float downForce = Vector2.Dot(-standingDirection, a.rb.velocity);
                if(!isOnGround && downForce > 0) {
                    force += standingDirection * downForce / Time.deltaTime;
                }
                // reset double-jump variable if on the ground
                a.jumping.ResetJumpCount();
                isOnGround = true;
                g.Negate();
                if(becomeParentedToPlatform) {
                    if(stoodOn != hitInfo.collider.transform) {
                        stoodOn = hitInfo.collider.transform;
                        parentTransform.SetFrom(stoodOn);
                    }
                }
            } else {
                isOnGround = false;
                g.Refresh();
                if(becomeParentedToPlatform) {
                    //if(stoodOn != null) print("no parent");
                    stoodOn = null;
                    parentTransform.SetIdentity();
                }
            }
            a.GetComponent<Collider>().enabled = true;
            return force;
        }
        public Vector3 FixedUpdate(Rigidbody rb, AxisAgent a, ref Gravity gravity) {
            Vector3 standForce = Force(a, ref gravity);
            rb.AddForce(standForce);
            return standForce;
        }
    }
    public Stand stand;

    [System.Serializable]
    public class Jump {
        public TupleMinMax height = new TupleMinMax(1, 5);
        public float fullJumpPressDuration = 0.5f;
        public int maxJumps = 2;
        public bool jumpStartResetsVerticalMotion = true;

        /// how long the user has been holding jump
        float timeJumpHeld;
        /// how the jump is currently doing
        float currentJumpVelocity;
        float targetHeight;
        float heightReached;
#if SHOW_AXIS_MATH
        Vector3 jumpStart;
        float heightReachedTotal;
#endif
        bool jumpPeaked = false;
        /// whether or not the user is currently jumping
        bool jumpImpulseActive = false;
        int jumpsSoFar = 0;

        public enum JumpDirection { opposingGravity, opposingGroundSurface }
        GameObject jumpShow;
        public bool IsRequestingJump(AxisAgent a) { return !jumpImpulseActive && (a.input.jump || a.input.jumpHeld); }
        public bool IsJumping() { return currentJumpVelocity > 0; }
        public void ResetJumpCount() { jumpsSoFar = 0; }

        public Vector3 Force(AxisAgent a, ref Gravity g, ref Movement movement) {
            Vector3 force = Vector3.zero;
            Vector3 jumpDirection = -g.GetDirection();//onlyJumpAgainstGravity ? -g.GetDirection() : a.stand.GetSurfaceNormal();//
            // if the user wants to jump, and is allowed to jump again
            if(IsRequestingJump(a) && (jumpsSoFar < maxJumps)) {
#if SHOW_AXIS_MATH
                if(jumpsSoFar == 0) {
                    jumpStart = a.transform.position;
                    heightReachedTotal = 0;
                }
#endif
                heightReached = 0;
                timeJumpHeld = 0;
                jumpsSoFar++;
                targetHeight = height.min;
                float velocityRequiredToJump = Mathf.Sqrt(targetHeight * 2 * g.GetForce());
                // cancel out current jump/fall forces
                if(jumpStartResetsVerticalMotion) {
                    float motionInVerticalDirection = Vector3.Dot(jumpDirection, a.rb.velocity);
                    force -= (motionInVerticalDirection * jumpDirection) / Time.deltaTime;
                }
                // apply proper jump force
                currentJumpVelocity = velocityRequiredToJump;
                jumpPeaked = false;
                force += (jumpDirection * currentJumpVelocity) / Time.deltaTime;
                jumpImpulseActive = true;
                a.stand.SetOnGround(false);
            } else
            // if a jump is happening
            if(currentJumpVelocity > 0) {
                // handle jump height: the longer you hold jump, the higher you jump
                if(a.input.jumpHeld) {
                    timeJumpHeld += Time.deltaTime;
                    if(timeJumpHeld >= fullJumpPressDuration) {
                        targetHeight = height.max;
                        timeJumpHeld = fullJumpPressDuration;
                    } else {
                        targetHeight = height.Lerp(timeJumpHeld / fullJumpPressDuration);
                    }
                    if(heightReached < targetHeight) {
                        float requiredJumpVelocity = Mathf.Sqrt((targetHeight - heightReached) * 2 * g.GetForce());
                        float forceNeeded = requiredJumpVelocity - currentJumpVelocity;
                        force += (jumpDirection * forceNeeded) / Time.deltaTime;
                        currentJumpVelocity = requiredJumpVelocity;
                    }
                } else {
                    jumpImpulseActive = false;
                }
            }
            if(currentJumpVelocity > 0) {
                float moved = currentJumpVelocity * Time.deltaTime;
                heightReached += moved;
#if SHOW_AXIS_MATH
                heightReachedTotal += moved;
                Lines.Make(ref jumpShow, Color.black, jumpStart, a.transform.position, .5f, 0f);
#endif
                currentJumpVelocity -= g.GetForce() * Time.deltaTime;
            } else if(!jumpPeaked && !a.stand.IsOnGround()) {
                jumpPeaked = true;
                jumpImpulseActive = false;
            }
            return force;
        }

        public Vector3 FixedUpdate(Rigidbody rb, AxisAgent a, ref Gravity gravity, ref Movement movement) {
            Vector3 f = Force(a, ref gravity, ref movement);
            rb.AddForce(f);
            return f;
        }
    }
    public Jump jumping;

    [System.Serializable]
    public class Input {
        public enum Source { none, mouseAndKeyboard }
        [Tooltip("Where to get input from")]
        public Source source = Source.mouseAndKeyboard;
        /// [Header("Controller Variables, set automatically by reading controller input")]
        /// variable:+/-, forward:forward/backward, strafe:right/left, turn:right/left, pitch:down/up
        [HideInInspector] public float forward, strafe, turn, pitch;
        /// [Tooltip("button inputs")]
        [HideInInspector] public bool jump, jumpHeld, fire1, fire1Held, fire2, fire2Held, gravityToggle, fullStop, invertPitch, runHeld;

        public void ReleaseAllInput() {
            forward = strafe = turn = pitch = 0; //mouseWheel = 0;
            jump = jumpHeld = fire1 = fire1Held = fire2 = fire2Held = runHeld = false;
        }
        [System.Serializable]
        public class Sensitivity {
            [Tooltip("x mouse sensitivity")]
            public float horizontal = 10F;
            [Tooltip("y mouse sensitivity")]
            public float vertical = 5F;
        }
        public Sensitivity sensitivity;

        public void LoadInputFromController() {
            switch(source) {
            case Source.none: break;
            case Source.mouseAndKeyboard:
                forward = UnityEngine.Input.GetAxis("Vertical");
                strafe = UnityEngine.Input.GetAxis("Horizontal");
                turn = UnityEngine.Input.GetAxis("Mouse X") * sensitivity.horizontal;
                pitch = -UnityEngine.Input.GetAxis("Mouse Y") * sensitivity.vertical;
                jump = UnityEngine.Input.GetButtonDown("Jump");
                jumpHeld = UnityEngine.Input.GetButton("Jump");
                fire1 = UnityEngine.Input.GetButtonDown("Fire1");
                fire1Held = UnityEngine.Input.GetButton("Fire1");
                fire2 = UnityEngine.Input.GetButtonDown("Fire2");
                fire2Held = UnityEngine.Input.GetButton("Fire2");
                runHeld = UnityEngine.Input.GetKey(KeyCode.LeftShift)
                        ||UnityEngine.Input.GetKey(KeyCode.RightShift);
                break;
            default:
                throw new System.Exception("unsupported controller " + source);
            }
            if(invertPitch) pitch *= -1;
        }
    }
    public Input input;

    [System.Serializable]
    public class Movement {
        ///<summary>current movement force</summary>
        private Vector3 force;
        ///<summary>velocity vector if viewed directly from above</summary>
        private Vector3 groundVelocity;
        ///<summary>groundVelocity.magnitude</summary>
        private Vector3 groundDir;
        ///<summary>the direction according to the input</summary>
        private Vector3 inputDir;
        ///<summary>how much rise/fall is going on</summary>
        private float verticalVelocity;
        ///<summary>velocity absent rise/fall</summary>
        private float groundSpeed;
        ///<summary>max speed based on input, taking directional speed limits into account</summary>
        private float maxInputSpeed;
        ///<summary>how much faster the agent is going than the current speed limit</summary>
        private float overSpeed;

        public Vector3 defaultUpDirection = Vector3.up;

        Axis movementAxis;

        ///<summary>how far the 3rd person camera can move back based on obstacles in the way</summary>
        float distanceLimitedTo;
        ///<summary>where the 3rd person camera is</summary>
        float actualDistance;

#if SHOW_AXIS_MATH
        GameObject line_movementAxis;
#endif
        public Vector3 CalculatedSurfaceUpDirection(AxisAgent a) {
            return a.stand.IsOnGround() ? a.stand.GetSurfaceNormal() : defaultUpDirection;
        }

        public Vector3 Force(AxisAgent a, Settings s) {
            if(movementAxis == null) movementAxis = new Axis();
            movementAxis.SetFrom(a.body);
            Vector3 upDirection = (Mathf.Abs(a.stand.GetSurfaceAngle()) < s.maxIncline) ? CalculatedSurfaceUpDirection(a) : defaultUpDirection;//
            if(a.body.up != upDirection) {
                movementAxis.SetUpright(upDirection);
            }
#if SHOW_AXIS_MATH
            movementAxis.DrawThumbtack(ref line_movementAxis, Color.blue, 2, .0625f);
            movementAxis.WriteInto(line_movementAxis.transform);
#endif
            force = Vector3.zero;
            verticalVelocity = Vector3.Dot(defaultUpDirection, a.rb.velocity);
            groundVelocity = a.rb.velocity - (defaultUpDirection * verticalVelocity);
            groundSpeed = groundVelocity.magnitude;
            groundDir = groundVelocity / groundSpeed;
            inputDir = Vector3.zero;
            // input impulse
            if(a.input.forward != 0 || a.input.strafe != 0) {

                maxInputSpeed = s.GetSpeedBasedOnInput(a.input, a.stand.GetSurfaceAngle());
                inputDir = movementAxis.forward * a.input.forward + movementAxis.GetRight() * a.input.strafe;
                inputDir.Normalize();
                float accelSpeedInCurrentDirection = Vector3.Dot(inputDir, groundVelocity);
                force = inputDir * ((accelSpeedInCurrentDirection > 0) ? s.acceleration : s.deceleration);
                if(groundSpeed > maxInputSpeed) {
                    overSpeed = Vector3.Dot(groundDir, force);
                    overSpeed += groundSpeed - maxInputSpeed;
                    force += groundDir * -overSpeed;
                    force = force.normalized * s.acceleration;
                }
            } else {
                // stop logic
                if(s.stopWhenNoInputGiven && groundSpeed != 0) {
                    // figure out how much force is needed to stop
                    float stopNeededToBringToZero = groundSpeed / Time.deltaTime;
                    // if that is too much force, go with the max possible.
                    if(stopNeededToBringToZero > s.deceleration) {
                        force += -groundDir * s.deceleration;
                    } else {
                        force += -groundDir * stopNeededToBringToZero;
                    }
                }
            }
            return force;
        }

        [System.Serializable]
        public class Settings {
            [Tooltip("What to use this movement profile. For example, there could be different movement settings for: walk, run, crawl, swim, climb, parkour, jump, fall, fly, hover")]
            public string name = "standard";
            [Tooltip("Maximum speed when pressing forward/backward")]
            public float speedForward = 15, speedBackward = 5;
            [Tooltip("Maximum speed when pressing strafe right/left")]
            public float speedRight = 10, speedLeft = 10;
            [Tooltip("Maximum acceleration when going forward/backward or strafing right/left")]
            public float acceleration = 20;
            [Tooltip("Maximum acceleration when bringing velocity toward zero")]
            public float deceleration = 30;
            [Tooltip("If true, movement calculations will cause a stop if inputs are released")]
            public bool stopWhenNoInputGiven = true;
            [Tooltip("the agent will not be able to move around on surfaces with an incline greater than this")]
            public float maxIncline = 50;
            [Tooltip("Percentage of speed possible as the current surface angle approaches the max incline")]
            public AnimationCurve inclineSpeedLoss = AnimationCurve.Linear(0,0,1,1);

            /// TODO implement these for hover, climb, and parkour movement types
            [Tooltip("Acts against gravity force")]
            public float antiGravityForce = 0;
            [Tooltip("Causes gravity to match player up direction, the stronger force the more un-aligned with gravity it will work")]
            public float gravityRealignForce = 0;

            public float GetInclineSpeedAdjustment(float surfaceAngle) {
                return (surfaceAngle > 0) ? (1-inclineSpeedLoss.Evaluate(surfaceAngle / maxIncline)) :1;
            }

            [System.Serializable]
            public class HeadTurning {
                public TupleMinMax pitchLimit = new TupleMinMax(-140, 110);
                float currentVerticalAngle;
                // TODO allow the head transform to turn independently of the body, and make the body match if the turnLimit is reached or movement starts
//              public TupleMinMax turnLimit = new TupleMinMax(-50, 50);
//              public bool turnBodyBeyondMaximum = true;
//              public bool pitchBodyBeyondMaximum = false;

                public void Update(AxisAgent a) {
                    if(a.input.pitch != 0) {
                        a.face.SetFrom(a.head);
                        a.face.Pitch(a.input.pitch);
                        currentVerticalAngle = Vector3.Angle(a.body.up, a.face.up);
                        if(Vector3.Dot(a.face.forward, a.body.up) > 0) {
                            currentVerticalAngle *= -1;
                        }
                        float difference = pitchLimit.Difference(currentVerticalAngle);
                        if(difference != 0) {
                            a.face.Pitch(difference);
                            currentVerticalAngle += difference;
                        }
                        a.face.WriteInto(a.head);
                        thirdPersonCamera.CameraAngleUpdate(a.playerCamera, pitchLimit.PercentageOf(currentVerticalAngle));
                    }
                    float wheel = UnityEngine.Input.GetAxis("Mouse ScrollWheel");
                    if(wheel != 0) {
                        thirdPersonCamera.Move(a.playerCamera.transform, wheel);
                    }
                }

                [System.Serializable]
                public class ThirdPersonCameraController {
                    [Tooltip("How far the user wants the camera to be")]
                    public float thirdPersonDistance = 10;
                    [Tooltip("How quickly to move the camera to it's spot (lower is faster)"), Range(1, 128)]
                    public float collisionSpeed = 8;
                    public AnimationCurve viewAngle3rdPerson = DefaultCameraLookCurve();

                    public static AnimationCurve DefaultCameraLookCurve() {
                        AnimationCurve curve = new AnimationCurve();
                        curve.AddKey(0, 0);
                        curve.AddKey(.5f, .25f);
                        curve.AddKey(.75f, .25f);
                        curve.AddKey(1, 1);
                        return curve;
                    }

                    public void Move(Transform camera, float change) {
                        change *= 5;
                        thirdPersonDistance -= change;
                        if(thirdPersonDistance < change) {
                            camera.position = camera.parent.position;
                            thirdPersonDistance = 0;
                        }
                    }

                    public void CameraAngleUpdate(Camera camera, float vertical) {
                        vertical = viewAngle3rdPerson.Evaluate(vertical);
                        float fieldOfView = camera.fieldOfView;
                        float viewAngle = fieldOfView * vertical;
                        camera.transform.localRotation = Quaternion.Euler(viewAngle - 30, 0, 0);
                    }
                }
                public ThirdPersonCameraController thirdPersonCamera = new ThirdPersonCameraController();
            }
            public HeadTurning headTurning = new HeadTurning();

            [System.Serializable]
            public class RotationControl {
                [Tooltip("Be precise when turning with the mouse (no lag, or continued turning)")]
                public bool stopControlledAngularVelocity = true;
                [Tooltip("stop the spinning!")]
                public bool stopUncontrolledAngularVelocity = true;
                [Tooltip("set the player standing correctly if angle is perterbed")]
                public bool automaticallySetRightsideUp = true;
                [Tooltip("Force used to stop uncontrolled angular rotation")]
                public Vector3 angularVelocityCounterForce = new Vector3(15, 90, 15);
                [Tooltip("Force used to set player upright")]
                public float rightsideUpForce = 20;
            }
            public RotationControl rotationControl = new RotationControl();

            public Settings(float forward, float backward, float strafeRight, float strafeLeft, float accel, float decel) {
                this.speedForward = forward;
                this.speedBackward = backward;
                this.speedRight = strafeRight;
                this.speedLeft = strafeLeft;
                this.acceleration = accel;
                this.deceleration = decel;
            }

            public float GetSpeedBasedOnInput(Input i, float angle) {
                float result;
                if(i.forward == 0) {
                    if(i.strafe == 0) result = 0;
                    else if(i.strafe < 0) result = speedLeft;
                    else result = speedRight;
                } else if(i.strafe == 0) {
                    if(i.forward > 0) result = speedForward;
                    else result = speedBackward;
                } else {
                    float sum, f, s;
                    if(i.forward > 0) {
                        f = i.forward;
                        if(i.strafe > 0) { s = i.strafe; sum = f + s; f /= sum; s /= sum; result = (f * speedForward) + (s * speedRight); }
                        else             { s = -i.strafe; sum = f + s; f /= sum; s /= sum; result = (f * speedForward) + (s * speedLeft); }
                    } else {
                        f = -i.forward;
                        if(i.strafe > 0) { s = i.strafe; sum = f + s; f /= sum; s /= sum; result = (f * speedBackward) + (s * speedRight); }
                        else             { s = -i.strafe; sum = f + s; f /= sum; s /= sum; result = (f * speedBackward) + (s * speedLeft); }
                    }
                }
                return result * GetInclineSpeedAdjustment(angle);
            }
        }

        public Settings currentSettings = new Settings(15, 5, 10, 10, 20, 60);

        private Vector3 angularJerk, standUpJerk;

#if SHOW_AXIS_MATH
        /// visuals to help debug rotation forces
        GameObject rot_axis, rot_fwd, rot_up, rot_target;
#endif
        public void FixedUpdateRotation(AxisAgent a, Input inputSource, Transform transform, Axis body, Rigidbody rb) {
            bool balancingRotation = false;
            // if the agent is controlling angular jerks, to emulate precise rotation, and there was an angular jerk last frame
            if(currentSettings.rotationControl.stopControlledAngularVelocity && angularJerk != Vector3.zero) {
                // find out how much that angular jerk has depreciated
                Vector3 adjusted = angularJerk - (angularJerk * rb.angularDrag * Time.deltaTime);
                // remove the jerk from the current angular rotation
                rb.AddTorque(-adjusted, ForceMode.Acceleration);
                // mark that there is no more angular jerk (it has been undone)
                angularJerk = Vector3.zero;
                // mark thata balancing rotation occured, which will prevent further balancing rotations
                balancingRotation = true;
            }
            if(currentSettings.rotationControl.automaticallySetRightsideUp && body.up != defaultUpDirection) {
                Quaternion uprightRotation = body.GetUpright(defaultUpDirection);
                Quaternion rotationToRightSelf = body.DeltaTo(uprightRotation);//body.UprightDelta(-gravity.GetDirection());
                Vector3 euler = rotationToRightSelf.eulerAngles;
                bool change = false;
                if(euler.x > 180) { euler.x -= 360; change = true; }
                if(euler.y > 180) { euler.y -= 360; change = true; }
                if(euler.z > 180) { euler.z -= 360; change = true; }
                const float epsilon = 1 / 128f;
                if(Mathf.Abs(euler.x) < epsilon) euler.x = 0;
                if(Mathf.Abs(euler.y) < epsilon) euler.y = 0;
                if(Mathf.Abs(euler.z) < epsilon) euler.z = 0;
                if(change) {
                    //print(Time.time+":["+euler.x + " " + euler.y + " " + euler.z+"]");
                    rotationToRightSelf = Quaternion.Euler(euler);
                }
                if(euler != Vector3.zero) {
                    Vector3 rotAxis = Vector3.zero;
                    float rotAngle;
                    rotationToRightSelf.ToAngleAxis(out rotAngle, out rotAxis);
#if SHOW_AXIS_MATH
                    Lines.Make(ref rot_axis, Color.magenta, transform.position + rotAxis, transform.position - rotAxis, .1f, .1f);
                    Lines.MakeArc(ref rot_fwd, Color.magenta, transform.position, rotAxis, transform.forward, rotAngle, 8, .1f, 0);
                    Lines.MakeArc(ref rot_up, Color.magenta, transform.position, rotAxis, transform.up, rotAngle, 8, .1f, 0);
                    Axis next = new Axis(body);
                    next.Rotate(rotationToRightSelf);
                    next.DrawSimple(ref rot_target, Color.black, 1);
#endif
                    float f = currentSettings.rotationControl.rightsideUpForce;
                    euler.x = Mathf.Clamp(euler.x, -f, f);
                    euler.y = Mathf.Clamp(euler.y, -f, f);
                    euler.z = Mathf.Clamp(euler.z, -f, f);
                    //print(Time.time + ": " + euler.x + " " + euler.y + " " + euler.z);
                    if(standUpJerk != euler) {
                        // divide by 2 because... it makes it work better. TODO more controlled right-side-up angular forces!
                        rb.AddTorque(-standUpJerk/2, ForceMode.Acceleration);
                        standUpJerk = euler;
                        rb.AddTorque(euler, ForceMode.Acceleration);
                    }
                }
            }
            // if the player wants to turn (horizontal motion)
            if(inputSource.turn != 0) {
                // turn horizontally
                angularJerk.y += inputSource.turn / Time.deltaTime;
                rb.AddTorque(angularJerk, ForceMode.Acceleration);
            } else {
                // if no turn is going on, and no balancing rotation is going on, and this agent should be stopping uncontrolled rotations
                if(currentSettings.rotationControl.stopUncontrolledAngularVelocity && !balancingRotation) {
                    // if there is rotation
                    Vector3 angle = rb.angularVelocity;
                    if(angle != Vector3.zero) {
                        // calculate a counter-force to stop rotation
                        Vector3 counterForce = currentSettings.rotationControl.angularVelocityCounterForce;// Vector3.zero;
                        counterForce.x = Mathf.Clamp(angle.x, -counterForce.x, counterForce.x);
                        counterForce.y = Mathf.Clamp(angle.y, -counterForce.y, counterForce.y);
                        counterForce.z = Mathf.Clamp(angle.z, -counterForce.z, counterForce.z);
                        rb.AddTorque(-counterForce / Time.deltaTime, ForceMode.Acceleration);
                    }
                }
            }
        }

        public Vector3 Force(AxisAgent a) {
            return Force(a, currentSettings);
        }

        public Vector3 FixedUpdate(Rigidbody rb, AxisAgent a) {
            Vector3 f = Force(a);
            rb.AddForce(f);
            return f;
        }

        public void MoveCameraBack(Transform camera) {
            float thirdPersonDistance = currentSettings.headTurning.thirdPersonCamera.thirdPersonDistance;
            if(thirdPersonDistance == 0) return;
            RaycastHit rh = new RaycastHit();
            Vector3 dir = -camera.parent.forward;
            float nextPosition = actualDistance;
            if(!Physics.Raycast(camera.parent.position, dir, out rh, thirdPersonDistance)) {
                distanceLimitedTo = thirdPersonDistance;
            } else {
                distanceLimitedTo = rh.distance;
            }
            if(actualDistance != distanceLimitedTo) {
                float delta = (distanceLimitedTo - actualDistance) / currentSettings.headTurning.thirdPersonCamera.collisionSpeed;
                nextPosition = (Mathf.Abs(delta) > 1 / 128.0f) ? (actualDistance + delta) : distanceLimitedTo;
            }
            if(nextPosition != actualDistance) {
                actualDistance = nextPosition;
                camera.localPosition = -Vector3.forward * actualDistance;
            }
        }

        public void Update(AxisAgent a) {
            currentSettings.headTurning.Update(a);
            MoveCameraBack(a.playerCamera.transform);
        }
    }

    [Tooltip("Variables that set how this agent moves, and keep track of orientation")]
    public Movement movement;

    public void SetMovementSettings(Movement.Settings moveSettings) {
        movement.currentSettings = moveSettings;
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    /// uses Rigidbody.AddForce() to modify the rigidbody's behavior.
    void FixedUpdate () {
        // update axis
        body.SetFrom(transform);
        face.SetFrom(head);
        // update components. keep track of forces locally so visuals can be updated
        Vector3 moveForce = movement.FixedUpdate(rb, this);
        Vector3 gravityForce = gravity.FixedUpdate(rb);
        Vector3 jumpingForce = jumping.FixedUpdate(rb, this, ref gravity, ref movement);
        Vector3 standForce = stand.FixedUpdate(rb, this, ref gravity);
        // TODO RotationMovement
        movement.FixedUpdateRotation(this, input, transform, body, rb);
#if SHOW_AXIS_MATH
        DrawAxisOnTransform(ref line_body, Color.cyan, body, transform, .75f);
        DrawAxisOnTransform(ref line_head, Color.yellow, face, head, .5f);
        Vector3 p = transform.position;
        Vector3 s = stand.GetGroundContact();
        Vector3 v = transform.position + rb.velocity;
        Lines.Make(ref line_gravity, Color.magenta, p, p + gravityForce, .2f, 0);
        Lines.Make(ref line_stand, Color.green, s, s + standForce, .4f, 0);
        Lines.Make(ref line_velocity, Color.blue, p, v, .1f, .1f);
        Lines.Make(ref line_move, Color.red, v, v + moveForce, .1f, .1f);
#endif
    }

#if SHOW_AXIS_MATH
    void DrawAxisOnTransform(ref GameObject line_, Color c, Axis a, Transform t, float size) {
        a.DrawThumbtack(ref line_, c, size, .1f);
        line_.transform.SetParent(t);
        line_.transform.localPosition = Vector3.zero;
        line_.transform.localRotation = Quaternion.identity;
    }
#endif

    struct MoveSettingsManager {
        Movement.Settings defaultMoveSetting;
        [Tooltip("walk, run, crawl, swim, climb, parkour, jump, fall, fly, hover")]
        public Movement.Settings[] movementSettings;
        // TODO run button, crawl button, fly minimum speed float, swim boolean toggle
        // walk is standard movement, just slow. motion axis aligns with ground, if in the air, it aligns with player-up
        //     if crawl and run pressed while standing)
        // crawl crouches the player, and is very slow movement (with a smaller height profile)
        //     crawl button. jump stands player up
        // run is standard movement, but fast.
        //     automatically parkour if on non-ground surface
        // climb aligns gravity to be against a surface, allowing scaling of walls (and ceiling too if gravity alignment force is strong enough)
        //     if crawl and run pressed while against non-walkable surface. jump ends climb, and goes into jump (fall)
        // parkour causes player-up to shift when running on surfaces, and aligns gravity if able, allowing wall running (and ceiling running if gravity alignment force is strong enough)
        //     if running at surface that is too steep to be ground. release run to drop into standard movement. crawl to climb.
        // fall activates when the player is jumping or falling (non air-movement, but still in the air)
        //     jump again for double jump. if no more double jumps possible, go into hover.
        // hover is an air-travel, feels like no-clip movement in a FPS game. jump is up, crawl is down. uses antigravity force to balance out gravity. re-orient to up after movement and turning stops.
        //     activate if pressing jump during fall at the end of last double-jump. run to drop into fall, or switch into fly if speed is sufficient
        // fly is a fast air-travel, like a flight-sim, where left and right roll, forward and back pitch. player-up is not bound to gravity. must be in motion. free look. slowing down drops player into hover
        //     crawl to drop into fall, falling to minimum speed drops into fall
        // swim is triggered when entering a swim zone (water). dramatically reduces gravity, and makes the motion axis align with the look axis, allowing motion in any direction
        //     climb works. leave swim zone to end swim. jump to go into hover
        //     (water areas have a move-speed modifier and direction of flow)
    }

    void Start() {
        rb = GetComponent<Rigidbody>();
        rb.useGravity = false;
        rb.angularDrag = 0;
        rb.maxAngularVelocity = 360;
    }

    void Update() {
        input.LoadInputFromController();
        movement.Update(this);
    }
}