testss

Assets/Scripts/Blinky.cs

@@ -0,0 +1,90 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering.Universal;
+
+public class Blinky : MonoBehaviour
+{
+    public Light2D myLight;
+    public bool blinked = false;
+    public Color overdrive_color = Color.white;
+    private Color classic_color;
+    private int insane_counter = 0;
+    public int insane_counter_max = 20;
+    public float overdrive_intensity = 4;
+    private float default_intensity;
+    private float temp_intensity = 1;
+    public bool dimming = false;
+    public AudioSource lightsnd;
+    public BlockLighter blocklighter;
+    float ZMove = 0f;
+    float ZyMove = 0f;
+    Vector3 lightpos;
+    // Start is called before the first frame update
+    void Start()
+    {
+        classic_color = myLight.color;
+        default_intensity = myLight.intensity;
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        ZMove = Input.GetAxisRaw("Z") * 4;
+        ZyMove = Input.GetAxisRaw("Zy") * 4 * (true ? -1 : 1);
+        lightpos.x = ZMove;
+        lightpos.y = ZyMove;
+        transform.localPosition = lightpos;
+        if (Input.GetButtonDown("Blink") && !blinked)
+        {
+            blinked = true;
+            myLight.intensity = overdrive_intensity;
+            myLight.color = overdrive_color;
+            lightsnd.transform.position = transform.position;
+            blocklighter.LightThem();
+            lightsnd.Play();
+        }
+        if (blinked && !dimming)
+        {
+            if (insane_counter >= insane_counter_max)
+            {
+                insane_counter = 0;
+                temp_intensity = overdrive_intensity;
+                dimming = true;
+                blinked = false;
+            }
+            else
+            {
+                insane_counter += 1;
+            }
+        }
+        if (dimming == true)
+        {
+            if (temp_intensity > default_intensity)
+            {
+                myLight.intensity = temp_intensity;
+                temp_intensity -= 1f / insane_counter_max;
+
+            }
+            if (temp_intensity < default_intensity)
+            {
+                temp_intensity = default_intensity;
+            }
+            else if (temp_intensity == default_intensity)
+            {
+                myLight.color = classic_color;
+                myLight.intensity = default_intensity;
+                lightsnd.Stop();
+                dimming = false;
+            }
+        }
+        if (temp_intensity > default_intensity)
+        {
+            myLight.color = overdrive_color;
+        }
+        if (temp_intensity == default_intensity)
+        {
+            myLight.color = classic_color;
+        }
+    }
+}

Assets/Scripts/BlockLighter.cs

@@ -0,0 +1,52 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+public class BlockLighter : MonoBehaviour
+{
+    float distance;
+    RaycastHit2D[] hits;
+    public Blinky blinky;
+    public Transform lighty;
+    public int i = 0;
+    public Vector3 lightpos;
+    public GameObject[] allChildren;
+    // Start is called before the first frame update
+    void Start()
+    {
+        allChildren = new GameObject[transform.childCount];
+        //Find all child obj and store to that array
+        foreach (Transform child in transform)
+        {
+            allChildren[i] = child.gameObject;
+            i += 1;
+        }
+        foreach (GameObject child1 in allChildren)
+        {
+            foreach (GameObject child2 in allChildren)
+            {
+                Debug.DrawLine(child1.transform.position, child2.transform.position, Color.blue, 3f);
+            }
+        }
+    }
+
+    // Update is called once per frame
+   public void LightThem()
+    {
+        foreach (GameObject child in allChildren)
+        {
+            lightpos = new Vector3(lighty.transform.position.x, lighty.transform.position.y, lighty.transform.position.z);
+            Debug.DrawLine(lightpos, child.transform.position, Color.red, 5f);
+            hits = Physics2D.RaycastAll(lightpos, child.transform.position, 2f);
+            foreach (RaycastHit2D hit in hits)
+            {
+                distance = hit.distance;
+                if (hit.transform.tag.Equals("Level"))
+                {
+                    child.gameObject.SetActive(true);
+                }
+            }
+        }
+    }
+}

Assets/Scripts/CharacterController2D.cs

@@ -0,0 +1,146 @@
+using UnityEngine;
+using UnityEngine.Events;
+
+public class CharacterController2D : MonoBehaviour
+{
+	[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%
+	[Range(0, .3f)] [SerializeField] private float m_MovementSmoothing = .05f;	// How much to smooth out the movement
+	[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
+	[SerializeField] private Transform m_GroundCheck;							// A position marking where to check if the player is grounded.
+	[SerializeField] private Transform m_CeilingCheck;							// A position marking where to check for ceilings
+	[SerializeField] private Collider2D m_CrouchDisableCollider;				// A collider that will be disabled when crouching
+
+	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.
+	const float k_CeilingRadius = .2f; // Radius of the overlap circle to determine if the player can stand up
+	private Rigidbody2D m_Rigidbody2D;
+	private bool m_FacingRight = true;  // For determining which way the player is currently facing.
+	private Vector3 m_Velocity = Vector3.zero;
+
+	[Header("Events")]
+	[Space]
+
+	public UnityEvent OnLandEvent;
+
+	[System.Serializable]
+	public class BoolEvent : UnityEvent<bool> { }
+
+	public BoolEvent OnCrouchEvent;
+	private bool m_wasCrouching = false;
+
+	private void Awake()
+	{
+		m_Rigidbody2D = GetComponent<Rigidbody2D>();
+
+		if (OnLandEvent == null)
+			OnLandEvent = new UnityEvent();
+
+		if (OnCrouchEvent == null)
+			OnCrouchEvent = new BoolEvent();
+	}
+
+	private void FixedUpdate()
+	{
+		bool wasGrounded = m_Grounded;
+		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;
+				if (!wasGrounded)
+					OnLandEvent.Invoke();
+			}
+		}
+	}
+
+
+	public void Move(float move, bool crouch, bool jump)
+	{
+		// If crouching, check to see if the character can stand up
+		if (!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;
+			}
+		}
+
+		//only control the player if grounded or airControl is turned on
+		if (m_Grounded || m_AirControl)
+		{
+
+			// If crouching
+			if (crouch)
+			{
+				if (!m_wasCrouching)
+				{
+					m_wasCrouching = true;
+					OnCrouchEvent.Invoke(true);
+				}
+
+				// Reduce the speed by the crouchSpeed multiplier
+				move *= m_CrouchSpeed;
+
+				// Disable one of the colliders when crouching
+				if (m_CrouchDisableCollider != null)
+					m_CrouchDisableCollider.enabled = false;
+			} else
+			{
+				// Enable the collider when not crouching
+				if (m_CrouchDisableCollider != null)
+					m_CrouchDisableCollider.enabled = true;
+
+				if (m_wasCrouching)
+				{
+					m_wasCrouching = false;
+					OnCrouchEvent.Invoke(false);
+				}
+			}
+
+			// Move the character by finding the target velocity
+			Vector3 targetVelocity = new Vector2(move * 10f, m_Rigidbody2D.velocity.y);
+			// And then smoothing it out and applying it to the character
+			m_Rigidbody2D.velocity = Vector3.SmoothDamp(m_Rigidbody2D.velocity, targetVelocity, ref m_Velocity, m_MovementSmoothing);
+
+			// 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)
+		{
+			// Add a vertical force to the player.
+			m_Grounded = 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/Scripts/Parallax.cs

@@ -0,0 +1,27 @@
+using UnityEngine;
+
+public class Parallax : MonoBehaviour
+{
+
+	private float length, startPos;
+	public GameObject cam;
+	public float parallexEffect;
+
+	void Start()
+	{
+		startPos = transform.position.x;
+		length = GetComponent<SpriteRenderer>().bounds.size.x;
+	}
+
+	void FixedUpdate()
+	{
+		float temp = (cam.transform.position.x * (1 - parallexEffect));
+		float dist = (cam.transform.position.x * parallexEffect);
+
+		transform.position = new Vector3(startPos + dist, transform.position.y, transform.position.z);
+
+		if (temp > startPos + length) startPos += length;
+		else if (temp < startPos - length) startPos -= length;
+	}
+
+}

Assets/Scripts/PlayerMovement.cs

@@ -0,0 +1,67 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+
+public class PlayerMovement : MonoBehaviour
+{
+    public CharacterController2D controller;
+
+    float HorizontalMove = 0f;
+    float VerticalMove = 0f;
+    bool jump = false;
+    bool jumping = false;
+    public Animator animator;
+    bool crouch = false;
+    bool crouching = false;
+    public float RunSpeed = 80f;
+    public AudioSource jumpsnd;
+
+    // Update is called once per frame
+    void Update()
+    {
+        
+
+        VerticalMove = Input.GetAxisRaw("Vertical");
+        HorizontalMove = Input.GetAxisRaw("Horizontal") * RunSpeed;
+
+        animator.SetBool("Jumping", jumping);
+        animator.SetBool("Crouching", crouching);
+        animator.SetFloat("Speed", HorizontalMove);
+
+        if (transform.position.y < -23f)
+        {
+            transform.position = new Vector3(-2.18f, -11.78f, 0);
+        }
+
+        if ((VerticalMove > 0.8 || Input.GetButtonDown("Jump")) && !jumping)
+        {
+            jump = true;
+            jumping = true;
+            jumpsnd.transform.position = transform.position;
+            jumpsnd.Play();
+            
+        }
+        if (VerticalMove < -0.8 || Input.GetButtonDown("Crouch"))
+        {
+            crouch = true;
+        } else if (Input.GetButtonUp("Crouch") || VerticalMove > -0.8)
+        {
+            crouch = false;
+        }
+    }
+    void FixedUpdate()
+    {
+        controller.Move(HorizontalMove * Time.fixedDeltaTime, crouch, jump);
+        jump = false;
+    }
+    public void OnLanding()
+    {
+        jumping = false;
+        jumpsnd.Stop();
+    }
+    public void OnCrouch(bool IsCrouching)
+    {
+        crouching = IsCrouching;
+    }
+}
+