Esempio n. 1
0
    private void OnCollisionEnter2D(Collision2D collision)
    {
        KinematicBubble kinematicBubble = collision.gameObject.GetComponent <KinematicBubble>();

        if (kinematicBubble != null && collision.gameObject.CompareTag(gameObject.tag))
        {
            kinematicBubble.CountNumbersOfMyColliderAndDestroyIfNeeded();
        }
    }
Esempio n. 2
0
    private void OnTriggerEnter2D(Collider2D other)
    {
        KinematicBubble kinematicBubble = other.GetComponent <KinematicBubble>();

        if (kinematicBubble)
        {
            StartCoroutine(kinematicBubble.DestroyBubble());
        }
    }
 public void SetTimerAndCheckForDropAndRemoveFromList(KinematicBubble checkForDropBubble)
 {
     if (checkforDropList.Contains(checkForDropBubble))
     {
         checkforDropList.Remove(checkForDropBubble);
         timePassedForstartCheckingForDrop = 0;
         checkForDrop = true;
     }
 }
Esempio n. 4
0
    private void OnCollisionEnter2D(Collision2D other)
    {
        KinematicBubble kinematicBubble = other.collider.GetComponent <KinematicBubble>();

        if (kinematicBubble)
        {
            StartCoroutine(kinematicBubble.DestroyBubble());
            myAnimator.SetBool(fireBubbleBlowBoolName, true);
            gameObject.layer = 11;
        }
        // should chagne to corotine
        // maybe handle in animation event
    }
Esempio n. 5
0
    private void ChangeToKinematicBubble()
    {
        GetComponent <Rigidbody2D>().bodyType = RigidbodyType2D.Kinematic;
        KinematicBubble kinematicBubble = gameObject.AddComponent(typeof(KinematicBubble)) as KinematicBubble;

        kinematicBubble.SetTextCanvas(textCanvas);


        Destroy(myTrailRenderer);
        // myAnimator.SetBool("BubbleBlow", true);


        rigidbody2d.gravityScale = 1;
        gameObject.layer         = 9; // bubble
        kinematicBubble.CountNumbersOfMyColliderAndDestroyIfNeeded();
        Destroy(this);
    }
Esempio n. 6
0
    private void OnCollisionEnter2D(Collision2D other)
    {
        KinematicBubble kinematicBubble = other.collider.GetComponent <KinematicBubble>();

        if (kinematicBubble)
        {
            if (!kinematicBubbles.Contains(kinematicBubble))
            {
                kinematicBubbles.Add(kinematicBubble);
                kinematicBubble.CountNumbersOfMyColliderAndDestroyIfNeeded();
                // Debug.Log(kinematicBubble.name + "called from superBubble");

                //myAnimator.SetBool(fireBubbleBlowBoolName, true);

                Destroy(gameObject, 0.1f);
                gameObject.layer = 11;  // dont do physical action
            }
        }
    }
Esempio n. 7
0
    private void OnCollisionExit2D(Collision2D other)
    {
        KinematicBubble kinematicBubble = other.collider.GetComponent <KinematicBubble>();

        if (other.collider != null && kinematicBubble)
        {
            if (myCollider2D.enabled == true && other.collider.CompareTag(gameObject.tag) && kinematicBubble.IsObjAlive() == false &&
                kinematicBubble.GetDestroyWhenMyTypeDestroyed())
            {
                StartCoroutine(DestroyBubbleWhenMyTypeDestroyed());
                kinematicBubbleManager.SetTimerAndCheckForDropAndRemoveFromList(this);
            }
            else if (myCollider2D.enabled == true && kinematicBubble.IsObjAlive() == false && alive)
            {
                if (objIsAboutToBlow == false)
                {
                    kinematicBubbleManager.SetTimerAndCheckForDropAndAddToList(this);
                }
            }
        }
    }
 public void SetTimerAndCheckForDropAndAddToList(KinematicBubble checkForDropBubble)
 {
     checkforDropList.Add(checkForDropBubble);
     timePassedForstartCheckingForDrop = 0;
     checkForDrop = true;
 }
    private void CheckForDrop(KinematicBubble selectedBubble)
    {
        bool thereIsNotSelectedBubbleOnMyLine = true;

        for (int i = 0; i < lastSelectedBubbleYPos.Count; i++)
        {
            if (selectedBubble.transform.position.y == lastSelectedBubbleYPos[i])
            {
                thereIsNotSelectedBubbleOnMyLine = false;
            }
        }
        if (thereIsNotSelectedBubbleOnMyLine)
        {
            // find all sideNeighbours
            if (!selectedBubble.CheckForAnchor())
            {
                List <KinematicBubble> sideBubbles = new List <KinematicBubble>();
                lastSelectedBubbleYPos.Add(selectedBubble.transform.position.y);
                selectedBubble.FindNeighborsAndAddToList(sideBubbles, selectedBubble.transform.position);

                //foreach (KinematicBubble bubble in sideBubbles)
                //{
                //    Debug.Log(selectedBubble.name + " find = " + bubble.name + " his Side Neighbour");
                //}

                //check for anchor in that line

                bool orAllSideAnchors = false;
                foreach (KinematicBubble bubble in sideBubbles)
                {
                    orAllSideAnchors = orAllSideAnchors || bubble.CheckForAnchor();
                }

                if (orAllSideAnchors == false)
                {
                    foreach (KinematicBubble bubble in sideBubbles)
                    {
                        bubble.SetAnchor(false);
                    }
                    bool continueWhile = true;
                    while (continueWhile)
                    {
                        List <KinematicBubble> buttomBubbles = new List <KinematicBubble>();
                        foreach (KinematicBubble bubble in sideBubbles)
                        {
                            bubble.FindButtomsAndAddToList(buttomBubbles);
                        }
                        List <KinematicBubble> uniqButtomBubbles = buttomBubbles.Distinct().ToList();



                        List <KinematicBubble> buttomSide = new List <KinematicBubble>();
                        foreach (KinematicBubble bubble in uniqButtomBubbles)
                        {
                            bubble.FindNeighborsAndAddToList(buttomSide, bubble.transform.position);
                        }
                        List <KinematicBubble> uniqButtomSides = buttomSide.Distinct().ToList();


                        //check if there is no layer
                        if (uniqButtomSides.Count == 0)
                        {
                            // Debug.Log(selectedBubble.name+" Called Drop For Every one");
                            selectedBubble.Drop(selectedBubble.transform.position);
                            lastSelectedBubbleYPos.Clear();
                            continueWhile = false;
                        }
                        else
                        {
                            bool orAllAnchorsButtoms = false;
                            foreach (KinematicBubble bubble1 in uniqButtomSides)
                            {
                                //  Debug.Log(selectedBubble.name + " find = " + bubble1.name + " his ButtonSide Neighbour");
                                orAllAnchorsButtoms = orAllAnchorsButtoms || bubble1.CheckForAnchor();
                            }

                            if (orAllAnchorsButtoms == false)
                            {
                                // redo this while loop
                                foreach (KinematicBubble bubble in uniqButtomSides)
                                {
                                    bubble.SetAnchor(false);
                                }
                                sideBubbles = uniqButtomSides;
                            }
                            else
                            {
                                // dont continue and return
                                foreach (KinematicBubble bubble in uniqButtomSides)
                                {
                                    bubble.SetAnchor(true);
                                }
                                continueWhile = false;
                            }
                        }
                    }
                    //clear
                    lastSelectedBubbleYPos.Clear();
                }
                else
                {
                    foreach (KinematicBubble bubble in sideBubbles)
                    {
                        bubble.SetAnchor(true);
                    }
                    lastSelectedBubbleYPos.Clear();
                    //clear
                }
            }
        }
    }
 public void RemoveFromKinematicList(KinematicBubble kinematicBubble)
 {
     kinematicBubbles.Remove(kinematicBubble);
 }
 public void AddToKinematicList(KinematicBubble kinematicBubble)
 {
     // maybe change to interface
     kinematicBubbles.Add(kinematicBubble);
 }