Test

Assets/Standard Assets/2D/Scripts/Camera2DFollow.cs

@@ -0,0 +1,53 @@
+using System;
+using UnityEngine;
+
+namespace UnityStandardAssets._2D
+{
+    public class Camera2DFollow : MonoBehaviour
+    {
+        public Transform target;
+        public float damping = 1;
+        public float lookAheadFactor = 3;
+        public float lookAheadReturnSpeed = 0.5f;
+        public float lookAheadMoveThreshold = 0.1f;
+
+        private float m_OffsetZ;
+        private Vector3 m_LastTargetPosition;
+        private Vector3 m_CurrentVelocity;
+        private Vector3 m_LookAheadPos;
+
+        // Use this for initialization
+        private void Start()
+        {
+            m_LastTargetPosition = target.position;
+            m_OffsetZ = (transform.position - target.position).z;
+            transform.parent = null;
+        }
+
+
+        // Update is called once per frame
+        private void Update()
+        {
+            // only update lookahead pos if accelerating or changed direction
+            float xMoveDelta = (target.position - m_LastTargetPosition).x;
+
+            bool updateLookAheadTarget = Mathf.Abs(xMoveDelta) > lookAheadMoveThreshold;
+
+            if (updateLookAheadTarget)
+            {
+                m_LookAheadPos = lookAheadFactor*Vector3.right*Mathf.Sign(xMoveDelta);
+            }
+            else
+            {
+                m_LookAheadPos = Vector3.MoveTowards(m_LookAheadPos, Vector3.zero, Time.deltaTime*lookAheadReturnSpeed);
+            }
+
+            Vector3 aheadTargetPos = target.position + m_LookAheadPos + Vector3.forward*m_OffsetZ;
+            Vector3 newPos = Vector3.SmoothDamp(transform.position, aheadTargetPos, ref m_CurrentVelocity, damping);
+
+            transform.position = newPos;
+
+            m_LastTargetPosition = target.position;
+        }
+    }
+}

Assets/Standard Assets/2D/Scripts/Camera2DFollow.cs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 5d8238cc53530b64fbb7828c3d3bb591
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 

Assets/Standard Assets/2D/Scripts/CameraFollow.cs

@@ -0,0 +1,74 @@
+using System;
+using UnityEngine;
+
+
+namespace UnityStandardAssets._2D
+{
+    public class CameraFollow : MonoBehaviour
+    {
+        public float xMargin = 1f; // Distance in the x axis the player can move before the camera follows.
+        public float yMargin = 1f; // Distance in the y axis the player can move before the camera follows.
+        public float xSmooth = 8f; // How smoothly the camera catches up with it's target movement in the x axis.
+        public float ySmooth = 8f; // How smoothly the camera catches up with it's target movement in the y axis.
+        public Vector2 maxXAndY; // The maximum x and y coordinates the camera can have.
+        public Vector2 minXAndY; // The minimum x and y coordinates the camera can have.
+
+        private Transform m_Player; // Reference to the player's transform.
+
+
+        private void Awake()
+        {
+            // Setting up the reference.
+            m_Player = GameObject.FindGameObjectWithTag("Player").transform;
+        }
+
+
+        private bool CheckXMargin()
+        {
+            // Returns true if the distance between the camera and the player in the x axis is greater than the x margin.
+            return Mathf.Abs(transform.position.x - m_Player.position.x) > xMargin;
+        }
+
+
+        private bool CheckYMargin()
+        {
+            // Returns true if the distance between the camera and the player in the y axis is greater than the y margin.
+            return Mathf.Abs(transform.position.y - m_Player.position.y) > yMargin;
+        }
+
+
+        private void Update()
+        {
+            TrackPlayer();
+        }
+
+
+        private void TrackPlayer()
+        {
+            // By default the target x and y coordinates of the camera are it's current x and y coordinates.
+            float targetX = transform.position.x;
+            float targetY = transform.position.y;
+
+            // If the player has moved beyond the x margin...
+            if (CheckXMargin())
+            {
+                // ... the target x coordinate should be a Lerp between the camera's current x position and the player's current x position.
+                targetX = Mathf.Lerp(transform.position.x, m_Player.position.x, xSmooth*Time.deltaTime);
+            }
+
+            // If the player has moved beyond the y margin...
+            if (CheckYMargin())
+            {
+                // ... the target y coordinate should be a Lerp between the camera's current y position and the player's current y position.
+                targetY = Mathf.Lerp(transform.position.y, m_Player.position.y, ySmooth*Time.deltaTime);
+            }
+
+            // The target x and y coordinates should not be larger than the maximum or smaller than the minimum.
+            targetX = Mathf.Clamp(targetX, minXAndY.x, maxXAndY.x);
+            targetY = Mathf.Clamp(targetY, minXAndY.y, maxXAndY.y);
+
+            // Set the camera's position to the target position with the same z component.
+            transform.position = new Vector3(targetX, targetY, transform.position.z);
+        }
+    }
+}

Assets/Standard Assets/2D/Scripts/CameraFollow.cs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a9dfad760b6e9455593192a6d869f7ed
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 

Assets/Standard Assets/2D/Scripts/Platformer2DUserControl.cs

@@ -0,0 +1,40 @@
+using System;
+using UnityEngine;
+using UnityStandardAssets.CrossPlatformInput;
+
+namespace UnityStandardAssets._2D
+{
+    [RequireComponent(typeof (PlatformerCharacter2D))]
+    public class Platformer2DUserControl : MonoBehaviour
+    {
+        private PlatformerCharacter2D m_Character;
+        private bool m_Jump;
+
+
+        private void Awake()
+        {
+            m_Character = GetComponent<PlatformerCharacter2D>();
+        }
+
+
+        private void Update()
+        {
+            if (!m_Jump)
+            {
+                // Read the jump input in Update so button presses aren't missed.
+                m_Jump = CrossPlatformInputManager.GetButtonDown("Jump");
+            }
+        }
+
+
+        private void FixedUpdate()
+        {
+            // Read the inputs.
+            bool crouch = Input.GetKey(KeyCode.LeftControl);
+            float h = CrossPlatformInputManager.GetAxis("Horizontal");
+            // Pass all parameters to the character control script.
+            m_Character.Move(h, crouch, m_Jump);
+            m_Jump = false;
+        }
+    }
+}

Assets/Standard Assets/2D/Scripts/Platformer2DUserControl.cs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: c3d7b34a3bb2d4e4b926e7e729d3d410
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 

Assets/Standard Assets/2D/Scripts/PlatformerCharacter2D.cs

@@ -0,0 +1,115 @@
+using System;
+using UnityEngine;
+
+#pragma warning disable 649
+namespace UnityStandardAssets._2D
+{
+    public class PlatformerCharacter2D : MonoBehaviour
+    {
+        [SerializeField] private float m_MaxSpeed = 10f;                    // The fastest the player can travel in the x axis.
+        [SerializeField] private float m_JumpForce = 400f;                  // Amount of force added when the player jumps.
+        [Range(0, 1)] [SerializeField] private float m_CrouchSpeed = .36f;  // Amount of maxSpeed applied to crouching movement. 1 = 100%
+        [SerializeField] private bool m_AirControl = false;                 // Whether or not a player can steer while jumping;
+        [SerializeField] private LayerMask m_WhatIsGround;                  // A mask determining what is ground to the character
+
+        private Transform m_GroundCheck;    // A position marking where to check if the player is grounded.
+        const float k_GroundedRadius = .2f; // Radius of the overlap circle to determine if grounded
+        private bool m_Grounded;            // Whether or not the player is grounded.
+        private Transform m_CeilingCheck;   // A position marking where to check for ceilings
+        const float k_CeilingRadius = .01f; // Radius of the overlap circle to determine if the player can stand up
+        private Animator m_Anim;            // Reference to the player's animator component.
+        private Rigidbody2D m_Rigidbody2D;
+        private bool m_FacingRight = true;  // For determining which way the player is currently facing.
+
+        private void Awake()
+        {
+            // Setting up references.
+            m_GroundCheck = transform.Find("GroundCheck");
+            m_CeilingCheck = transform.Find("CeilingCheck");
+            m_Anim = GetComponent<Animator>();
+            m_Rigidbody2D = GetComponent<Rigidbody2D>();
+        }
+
+
+        private void FixedUpdate()
+        {
+            m_Grounded = false;
+
+            // The player is grounded if a circlecast to the groundcheck position hits anything designated as ground
+            // This can be done using layers instead but Sample Assets will not overwrite your project settings.
+            Collider2D[] colliders = Physics2D.OverlapCircleAll(m_GroundCheck.position, k_GroundedRadius, m_WhatIsGround);
+            for (int i = 0; i < colliders.Length; i++)
+            {
+                if (colliders[i].gameObject != gameObject)
+                    m_Grounded = true;
+            }
+            m_Anim.SetBool("Ground", m_Grounded);
+
+            // Set the vertical animation
+            m_Anim.SetFloat("vSpeed", m_Rigidbody2D.velocity.y);
+        }
+
+
+        public void Move(float move, bool crouch, bool jump)
+        {
+            // If crouching, check to see if the character can stand up
+            if (!crouch && m_Anim.GetBool("Crouch"))
+            {
+                // If the character has a ceiling preventing them from standing up, keep them crouching
+                if (Physics2D.OverlapCircle(m_CeilingCheck.position, k_CeilingRadius, m_WhatIsGround))
+                {
+                    crouch = true;
+                }
+            }
+
+            // Set whether or not the character is crouching in the animator
+            m_Anim.SetBool("Crouch", crouch);
+
+            //only control the player if grounded or airControl is turned on
+            if (m_Grounded || m_AirControl)
+            {
+                // Reduce the speed if crouching by the crouchSpeed multiplier
+                move = (crouch ? move*m_CrouchSpeed : move);
+
+                // The Speed animator parameter is set to the absolute value of the horizontal input.
+                m_Anim.SetFloat("Speed", Mathf.Abs(move));
+
+                // Move the character
+                m_Rigidbody2D.velocity = new Vector2(move*m_MaxSpeed, m_Rigidbody2D.velocity.y);
+
+                // If the input is moving the player right and the player is facing left...
+                if (move > 0 && !m_FacingRight)
+                {
+                    // ... flip the player.
+                    Flip();
+                }
+                    // Otherwise if the input is moving the player left and the player is facing right...
+                else if (move < 0 && m_FacingRight)
+                {
+                    // ... flip the player.
+                    Flip();
+                }
+            }
+            // If the player should jump...
+            if (m_Grounded && jump && m_Anim.GetBool("Ground"))
+            {
+                // Add a vertical force to the player.
+                m_Grounded = false;
+                m_Anim.SetBool("Ground", false);
+                m_Rigidbody2D.AddForce(new Vector2(0f, m_JumpForce));
+            }
+        }
+
+
+        private void Flip()
+        {
+            // Switch the way the player is labelled as facing.
+            m_FacingRight = !m_FacingRight;
+
+            // Multiply the player's x local scale by -1.
+            Vector3 theScale = transform.localScale;
+            theScale.x *= -1;
+            transform.localScale = theScale;
+        }
+    }
+}

Assets/Standard Assets/2D/Scripts/PlatformerCharacter2D.cs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: d08f91df3bd212f429df17f53ce2f364
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 

Assets/Standard Assets/2D/Scripts/Restarter.cs

@@ -0,0 +1,17 @@
+using System;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UnityStandardAssets._2D
+{
+    public class Restarter : MonoBehaviour
+    {
+        private void OnTriggerEnter2D(Collider2D other)
+        {
+            if (other.tag == "Player")
+            {
+                SceneManager.LoadScene(SceneManager.GetSceneAt(0).name);
+            }
+        }
+    }
+}

Assets/Standard Assets/2D/Scripts/Restarter.cs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: e053b0a94752146e79954ce4df1b5565
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: