Add files via upload

Author: chohongm

Attracted.cs

@@ -0,0 +1,37 @@
+using UnityEngine;
+using System.Collections;
+
+class Attracted : MonoBehaviour
+{
+    string text = ((int)(Random.value * 100)).ToString();
+
+    void Start()
+    {
+        gameObject.GetComponent<TextMesh>().text = text;
+    }
+
+    public GameObject attractedTo;
+    public float strengthOfAttraction = 1.0f;
+
+    void FixedUpdate ()
+    {
+        Vector3 direction = attractedTo.transform.position - transform.position;
+        gameObject.GetComponent<Rigidbody2D>().AddForce(strengthOfAttraction * direction);
+
+        //Vector3 relativePos = (attractedTo.transform.position + new Vector3(0, 1.5f, 0)) - transform.position;
+        //Quaternion rotation = Quaternion.LookRotation(relativePos);
+        //Quaternion current = transform.localRotation;
+        //transform.localRotation = Quaternion.Slerp(current, rotation, Time.deltaTime);
+        //transform.Translate(0, 0, 3 * Time.deltaTime);
+
+    }
+    /*
+    float RotationSpeed = 100f;
+    float OrbitDegrees = 2f;
+    void Update()
+    {
+        //transform.Rotate(Vector3.up, RotationSpeed * Time.deltaTime);
+        transform.RotateAround(attractedTo.transform.position, new Vector3(0, 0, 1), OrbitDegrees);
+    }
+    */
+}

BetterObjectPool.cs

@@ -0,0 +1,168 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+
+// By Anish Dhesikan
+public abstract class BetterObjectPool : MonoBehaviour {
+
+	public GameObject objectPrefab;
+
+	// initialMax: How many objects should the pool initially contain?
+	public int initialMax = 100;
+	// minInPool: What is the smallest number of items this pool should contain at any point?
+	public int minInPool = 20;
+
+	/*
+	 * -- How does it work? --
+	 * You can set 3 thresholds: lowerBound, middleBound, and upperBound. 
+	 * At any time, if the percent of active objects from the pool hits 
+	 * the lowerBound or upperBound thresholds, the object pool will begin to dynamically 
+	 * create or destroy objects to get the number back to the middle threshold. 
+	 * Try out the demo in ExampleScenes for more info.
+	 */
+	public float upperBound = 0.75f; // between 0 and 1
+	public float middleBound = 0.5f; // between 0 and 1
+	public float lowerBound = 0.25f; // between 0 and 1
+
+
+	// maxInstantiatesPerFrame: How many times can Instantiate() be called in a single frame?
+	// For mobile and for best performance in general, keep this number low.
+	// Currently, numbers less than 1 are not supported.
+	public int maxInstantiatesPerFrame = 1;
+
+	// maxDestroysPerFrame: How many times can Destroy() be called in a single frame?
+	// For mobile and for best performance in general, keep this number low.
+	// Currently, numbers less than 1 are not supported.
+	public int maxDestroysPerFrame = 1;
+
+	protected HashSet<GameObject> activeObjectPool = new HashSet<GameObject>();
+	protected Transform activeObjectPoolParent;
+	protected List<GameObject> inactiveObjectPool = new List<GameObject>();
+	protected Transform inactiveObjectPoolParent;
+
+	private int totalCount = 0;
+
+	private float percentActive = 1;
+
+	// Use this for initialization
+	public virtual void Awake () {
+		activeObjectPoolParent = new GameObject ("ActiveObjectPool " + objectPrefab.name).transform;
+		inactiveObjectPoolParent = new GameObject ("InactiveObjectPool" + objectPrefab.name).transform;
+		inactiveObjectPoolParent.gameObject.SetActive (false);
+		InstantiateMultiple (Mathf.FloorToInt(initialMax * middleBound));
+	}
+	
+	// Update is called once per frame
+	public virtual void Update () {
+		UpdatePercentActive ();
+		if (percentActive > upperBound) {
+			StopAllCoroutines ();
+			StartCoroutine (ScaleUp());
+		} else if (percentActive < lowerBound) {
+			StopAllCoroutines ();
+			StartCoroutine (ScaleDown());
+		}
+	}
+
+	IEnumerator ScaleUp () {
+		while (percentActive > middleBound) {
+			//Mathf.FloorToInt (Mathf.Pow (totalCount, 0.5f))
+			int numToInstantiate = Mathf.Min (maxInstantiatesPerFrame, Mathf.CeilToInt(totalCount / 200f));
+			InstantiateMultiple (numToInstantiate);
+			UpdatePercentActive ();
+			yield return 0;
+		}
+	}
+
+	IEnumerator ScaleDown () {
+		if (percentActive > 0 && totalCount > minInPool) {
+			while (percentActive < middleBound) {
+				DestroyMultiple (maxDestroysPerFrame);
+				UpdatePercentActive ();
+				yield return 0;
+			}
+		}
+	}
+
+	public virtual bool ObjectIsActive (GameObject instance) {
+		return activeObjectPool.Contains (instance);
+	}
+
+	public virtual void RemoveInstanceFromPool (GameObject instance) {
+		StopAllCoroutines ();
+		activeObjectPool.Remove (instance);
+		inactiveObjectPool.Add (instance);
+		instance.transform.parent = inactiveObjectPoolParent;
+	}
+
+	public virtual GameObject GetInstanceFromPool () {
+		StopAllCoroutines ();
+		GameObject curObject = null;
+		if (inactiveObjectPool.Count <= 0) {
+			InstantiateOne ();
+		}
+
+		curObject = inactiveObjectPool [0] as GameObject;
+//		curObject.SetActive (true);
+		inactiveObjectPool.Remove (curObject);
+		activeObjectPool.Add (curObject);
+		curObject.transform.parent = activeObjectPoolParent;
+
+		return curObject;
+	}
+
+	public virtual GameObject GetInstanceFromPool (Vector3 position, Quaternion rotation) {
+		GameObject curObject = GetInstanceFromPool ();
+		if (curObject != null) {
+			curObject.transform.position = position;
+			curObject.transform.rotation = rotation;
+		}
+		return curObject;
+	}
+
+	// Instantiates, deactivates, and adds one to the pool
+	private void InstantiateOne () {
+		GameObject newObject = Instantiate (objectPrefab) as GameObject;
+//		newObject.SetActive (false);
+		inactiveObjectPool.Add (newObject);
+		newObject.transform.parent = inactiveObjectPoolParent;
+		totalCount++;
+	}
+
+	private void InstantiateMultiple (int count) {
+		for (int i = 0; i < count; i++) {
+			InstantiateOne ();
+		}
+	}
+
+	private void DestroyOne () {
+		if (inactiveObjectPool.Count > 0) {
+			GameObject curObject = inactiveObjectPool [0] as GameObject;
+			inactiveObjectPool.Remove (curObject);
+			DestroyImmediate (curObject);
+			totalCount--;
+		}
+	}
+
+	private void DestroyMultiple (int count) {
+		for (int i = 0; i < count; i++) {
+			DestroyOne ();
+		}
+	}
+
+	public string GetInfoText () {
+		return "Percent Active:   " + percentActive * 100 + "%" + "\n" +
+			"Number Active:   " + activeObjectPool.Count + "\n" +
+			"Number Inactive: " + inactiveObjectPool.Count;
+	}
+
+	private void UpdatePercentActive () {
+		percentActive = (float) activeObjectPool.Count / totalCount;
+
+
+//		if (percentActive < lowerBound) {
+//			Debug.Log ("Percent Active: " + percentActive);
+//			Debug.Log ("TotalCount: " + totalCount);
+//		}
+	}
+}

BlackHole.cs

@@ -0,0 +1,69 @@
+using UnityEngine;
+using System.Collections;
+
+public class BlackHole : MonoBehaviour {
+
+    public float divisorDelay = 13.52f;
+    public float nextDivisor = 0f;
+    public CircleCollider2D collider;
+
+    public static int rand;
+
+    float threshold;
+    float scoreRadius;
+
+    void OnTriggerEnter2D(Collider2D col)
+    {
+        int entered;
+        
+        if (GameObject.FindObjectOfType<ScoreManager>().hasLost)
+        {
+            return;
+        }
+
+        if (int.TryParse(col.gameObject.GetComponent<TextMesh>().text, out entered))
+        {
+            if (entered % rand == 0)
+            {
+                GameObject.FindObjectOfType<ScoreManager>().score++;
+            }
+            else
+            {
+                GameObject.FindObjectOfType<ScoreManager>().score--;
+            }
+        }
+        Destroy(col.gameObject);
+    }
+	
+	// Update is called once per frame
+	void FixedUpdate () {
+
+        if (GameObject.FindObjectOfType<ScoreManager>().hasLost)
+        {
+            return;
+        }
+
+        threshold = FindObjectOfType<BoxLauncher>().debugValue;
+        collider = transform.GetComponent<CircleCollider2D>();
+        int score = FindObjectOfType<ScoreManager>().score;
+        if (score > 0)
+        {
+            scoreRadius = score / 100;
+
+        } else
+        {
+            scoreRadius = 0;
+        }
+
+        collider.radius = 0.6f + (threshold / 2f) + scoreRadius;
+
+        nextDivisor -= Time.deltaTime;
+
+        if (nextDivisor <= 0)
+        {
+            nextDivisor = divisorDelay;
+            rand = ((int)Random.Range(1, 9));
+            gameObject.GetComponent<TextMesh>().text = rand.ToString();
+        }
+    }
+}

BlackHoleSprite.cs

@@ -0,0 +1,15 @@
+using UnityEngine;
+using System.Collections;
+
+public class BlackHoleSprite : MonoBehaviour {
+
+    Vector3 scale;
+    float newScale;
+
+    // Update is called once per frame
+    void FixedUpdate () {
+        newScale = GameObject.FindObjectOfType<BlackHole>().collider.radius * 2;
+        scale = new Vector3(newScale, newScale, newScale);
+        transform.localScale = scale;
+    }
+}

BoxLauncher.cs

@@ -0,0 +1,80 @@
+using UnityEngine;
+using System.Collections;
+
+public class BoxLauncher : MonoBehaviour {
+
+    public GameObject objectPrefab;
+    //public string currLauncher = "LeftLauncher";
+
+    public float fireDelay = 6.76f; //6.76 for triforce music, 7.164 for techno music
+    public float fireVelocity = 22f;
+    public float cooldown = 1.6f;
+    public float nextFire = 0f;
+
+    public float spawnThreshold = 0.4f;
+    public int frequency = 3;
+    public FFTWindow fftWindow;
+    public float debugValue;
+
+    private float[] samples = new float[1024]; //MUST BE A POWER OF TWO
+
+    /*
+    // for moving the launcher as camera goes up
+    void Update()
+    {
+        Vector3 pos = transform.position;
+        float camYChange = Camera.main.GetComponent<CameraMover>().targetY - 
+                           Camera.main.GetComponent<CameraMover>().transform.position.y;
+        pos.y = Mathf.Lerp(transform.position.y, transform.position.y + camYChange, 1 * Time.deltaTime);
+        transform.position = pos;
+    }
+    */
+
+    void FixedUpdate()
+    {
+        if (nextFire > 0)
+        {
+            nextFire -= Time.deltaTime;
+        } else
+        {
+            nextFire = fireDelay;
+        }
+        cooldown -= Time.deltaTime;
+    }
+
+    // Update is called once per frame
+    void Update() {
+
+        if (GameObject.FindObjectOfType<ScoreManager>().hasLost)
+        {
+            return;
+        }
+
+        AudioListener.GetSpectrumData(samples, 0, fftWindow);
+
+        debugValue = samples[frequency];
+
+        if (nextFire <= 3.38) // 3.38 for triforce music, 3.582 for techno
+        {
+            if (cooldown <= 0 && samples[frequency] > spawnThreshold)
+            {
+                cooldown = 1.6f;
+                GameObject copy;
+                if (gameObject.transform.name == "TopLauncher")
+                {
+                    copy = (GameObject)Instantiate(
+                    objectPrefab,
+                    transform.position,
+                    transform.rotation * Quaternion.Euler(0, 0, 180));
+                } else
+                {
+                    copy = (GameObject)Instantiate(
+                    objectPrefab,
+                    transform.position,
+                    transform.rotation);
+                }
+                copy.GetComponent<Rigidbody2D>().velocity = transform.rotation * new Vector2(0, fireVelocity);
+            }
+        }
+	}
+}

CameraMover.cs

@@ -0,0 +1,14 @@
+using UnityEngine;
+using System.Collections;
+
+public class CameraMover : MonoBehaviour {
+
+    public float targetY = 0;
+	
+	// Update is called once per frame
+	void Update () {
+        Vector3 pos = transform.position;
+        pos.y = Mathf.Lerp(transform.position.y, targetY, 1 * Time.deltaTime);
+        transform.position = pos;
+	}
+}