Adds FloatPhysics (coroutine version)

Hold my beer while I see if I can now remove the 78% CPU (15 FPS!) performance issue it added

Author: omundy

Assets/_Project/Scripts/Physics.meta

@@ -0,0 +1,32 @@
+using UnityEngine;
+
+public class ColliderBounds : MonoBehaviour
+{
+    Collider m_Collider;
+    Vector3 m_Center;
+    Vector3 m_Size, m_Min, m_Max;
+
+    void Start()
+    {
+        //Fetch the Collider from the GameObject
+        m_Collider = GetComponent<Collider>();
+        //Fetch the center of the Collider volume
+        m_Center = m_Collider.bounds.center;
+        //Fetch the size of the Collider volume
+        m_Size = m_Collider.bounds.size;
+        //Fetch the minimum and maximum bounds of the Collider volume
+        m_Min = m_Collider.bounds.min;
+        m_Max = m_Collider.bounds.max;
+        //Output this data into the console
+        OutputData();
+    }
+
+    void OutputData()
+    {
+        //Output to the console the center and size of the Collider volume
+        Debug.Log("Collider Center : " + m_Center);
+        Debug.Log("Collider Size : " + m_Size);
+        Debug.Log("Collider bound Minimum : " + m_Min);
+        Debug.Log("Collider bound Maximum : " + m_Max);
+    }
+}

Assets/_Project/Scripts/Physics/ColliderBounds.cs

@@ -0,0 +1,116 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class FloatPhysics : MonoBehaviour
+{
+    // container
+    public Collider worldContainerCollider;
+
+
+    Rigidbody rb;                   // rb to apply force
+    public float forcemultiplier;   // use to generate new force directions
+    public bool applyNewForce;      // should we apply new force on loop?
+    public float newForceTime;      // the time before the current force expires
+    public Vector3 force;           // the force vector (speed + direction) 
+    public Vector3 forceInfluence;  // influence direction of force vector if it gets close to the boundaries
+    public float maxSpeed = 30f;    // max speed of rb
+
+    public Vector3 mousePos;
+
+    void Awake()
+    {
+        worldContainerCollider = GameObject.Find("WorldContainer").GetComponent<Collider>();
+        rb = GetComponent<Rigidbody>();
+    }
+
+    private void Update()
+    {
+        // first run 
+        applyNewForce = true;
+        // 1. start the force loop
+        StartCoroutine(ForceVectorGenerator());
+    }
+
+    void FixedUpdate()
+    {
+        if (rb.velocity.magnitude > maxSpeed)
+        {
+            rb.velocity = rb.velocity.normalized * maxSpeed;
+        }
+        if (applyNewForce)
+        {
+            // add whatever force is stored in the vector
+            rb.AddForce(force + forceInfluence);
+            applyNewForce = false;
+        }
+    }
+
+
+    // generate a new random direction at random times
+    IEnumerator ForceVectorGenerator()
+    {
+        // run forever
+        while (true)
+        {
+            // pick new time to wait before generating new force vector 
+            newForceTime = Random.Range(4.0f, 8.0f);
+
+            // if the GameObject has left the scene then push it back 
+            forceInfluence = ForceAwayFromWall(worldContainerCollider.bounds);
+
+            // generate new force vector 
+            force = new Vector3(
+                Random.Range(-forcemultiplier, forcemultiplier),
+                Random.Range(-forcemultiplier, forcemultiplier),
+                Random.Range(-forcemultiplier, forcemultiplier)
+            );
+
+            applyNewForce = true;
+
+            // wait for before next loop
+            yield return new WaitForSeconds(newForceTime);
+        }
+
+    }
+
+
+    Vector3 ForceAwayFromWall(Bounds bounds)
+    {
+        Vector3 newForce = new Vector3(0, 0, 0);
+
+        // X
+        if (gameObject.transform.position.x < bounds.min.x)
+        {
+            newForce.x += 2;
+        }
+        else if (gameObject.transform.position.x > bounds.max.x)
+        {
+            newForce.x -= 2;
+        }
+
+        // Y
+        if (gameObject.transform.position.y < bounds.min.y)
+        {
+            newForce.y += 2;
+        }
+        else if (gameObject.transform.position.y > bounds.max.y)
+        {
+            newForce.y -= 2;
+        }
+
+        // Z
+        if (gameObject.transform.position.z < bounds.min.z)
+        {
+            newForce.z += 2;
+        }
+        else if (gameObject.transform.position.z > bounds.max.z)
+        {
+            newForce.z -= 2;
+        }
+        return newForce;
+    }
+
+
+
+}

Assets/_Project/Scripts/Physics/ColliderBounds.cs.meta

@@ -0,0 +1,78 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+
+// found online https://answers.unity.com/questions/59934/how-to-an-object-floating-up-and-down.html
+// manipulates transform  :-(
+
+
+public class FloatTransform : MonoBehaviour
+{
+
+    public bool animPos = true;
+    public Vector3 posAmplitude = Vector3.one;
+    public Vector3 posSpeed = Vector3.one;
+
+    public bool animRot = true;
+    public Vector3 rotAmplitude = Vector3.one * 20;
+    public Vector3 rotSpeed = Vector3.one;
+
+    public bool animScale = false;
+    public Vector3 scaleAmplitude = Vector3.one * 0.1f;
+    public Vector3 scaleSpeed = Vector3.one;
+
+    private Vector3 origPos;
+    private Vector3 origRot;
+    private Vector3 origScale;
+
+    private float startAnimOffset = 0;
+
+
+    /**
+     * Awake
+     */
+    void Awake()
+    {
+        origPos = transform.position;
+        origRot = transform.eulerAngles;
+        origScale = transform.localScale;
+        startAnimOffset = Random.Range(0f, 540f);        // so that the xyz anims are already offset from each other since the start
+    }
+
+    /**
+     * Update
+     */
+    void Update()
+    {
+        /* position */
+        if (animPos)
+        {
+            Vector3 pos;
+            pos.x = origPos.x + posAmplitude.x * Mathf.Sin(posSpeed.x * Time.time + startAnimOffset);
+            pos.y = origPos.y + posAmplitude.y * Mathf.Sin(posSpeed.y * Time.time + startAnimOffset);
+            pos.z = origPos.z + posAmplitude.z * Mathf.Sin(posSpeed.z * Time.time + startAnimOffset);
+            transform.position = pos;
+        }
+
+        /* rotation */
+        if (animRot)
+        {
+            Vector3 rot;
+            rot.x = origRot.x + rotAmplitude.x * Mathf.Sin(rotSpeed.x * Time.time + startAnimOffset);
+            rot.y = origRot.y + rotAmplitude.y * Mathf.Sin(rotSpeed.y * Time.time + startAnimOffset);
+            rot.z = origRot.z + rotAmplitude.z * Mathf.Sin(rotSpeed.z * Time.time + startAnimOffset);
+            transform.eulerAngles = rot;
+        }
+
+        /* scale */
+        if (animScale)
+        {
+            Vector3 scale;
+            scale.x = origScale.x * (1 + scaleAmplitude.x * Mathf.Sin(scaleSpeed.x * Time.time + startAnimOffset));
+            scale.y = origScale.y * (1 + scaleAmplitude.y * Mathf.Sin(scaleSpeed.y * Time.time + startAnimOffset));
+            scale.z = origScale.z * (1 + scaleAmplitude.z * Mathf.Sin(scaleSpeed.z * Time.time + startAnimOffset));
+            transform.localScale = scale;
+        }
+    }
+}