Beispiel #1
0
    private void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.gameObject.GetComponent <Asteroid>() == null)
        {
            return;
        }

        Debug.Log("Player destroyed");

        OnPlayerDestroyed?.Invoke();
    }
Beispiel #2
0
    private void PlayerDestroyed()
    {
        PlayerShips--;
        OnPlayerDestroyed?.Invoke(PlayerShips);

        if (PlayerShips <= 0)
        {
            PlayerShips = 0;
            GameOver();
        }
    }
Beispiel #3
0
    /// <summary>
    /// <para>Invokes the OnShipDestroyed event</para>
    /// <para>If there are lives left, initializes the next available ship if there is any and invokes the
    /// OnPlayerDestroyed event.</para>
    /// <para>If there is no ships available then the OnAllShipsDestroyed event will be invoked</para>
    /// <remarks>This method is executed when a player ship is destroyed</remarks>
    /// </summary>
    /// <param name="ship"></param>
    private void OnShipDie(PlayerShip ship)
    {
        OnShipDestroyed?.Invoke(ship.PlayerController.gameObject);

        if (ship.PlayerController != ships[currentLife].PlayerController)
        {
            return;
        }

        currentLife++;
        livesUI.UpdateValue(lives - currentLife);
        if (currentLife >= lives)
        {
            OnAllShipsDestroyed?.Invoke();
        }
        else
        {
            InitializeShip();
            OnPlayerDestroyed?.Invoke();
        }
    }
Beispiel #4
0
    void OnTriggerEnter2D(Collider2D other)
    {
        switch (other.tag)
        {
        case "PointObject":
            if (OnScoreChange != null)
            {
                OnScoreChange.Invoke(1);     //When create a point object script add variable for point value
                Manager <SoundManager> .Instance.PlaySoundEffect(SoundManager.SoundEffect.Pickup);
            }
            Destroy(other.gameObject);     //When create a point object script create destroy object function to call
            break;

        case "EndLevel":
            if (OnLevelEnd != null)
            {
                OnLevelEnd.Invoke();
                Manager <SoundManager> .Instance.PlaySoundEffect(SoundManager.SoundEffect.EndLevel);
            }
            break;

        case "DestroyPlayer":
            if (OnPlayerDestroyed != null)
            {
                OnPlayerDestroyed.Invoke();
                Manager <InputManager> .Instance.OnCharacterRelease -= ReleaseCharacter;
                Manager <InputManager> .Instance.OnMoveLeft         -= MoveLeft;
                Manager <InputManager> .Instance.OnMoveRight        -= MoveRight;
                Manager <InputManager> .Instance.OnJump             -= Jump;
                Destroy(this.gameObject);
            }
            break;

        default:
            break;
        }
    }
Beispiel #5
0
    // Update is called once per frame
    void Update()
    {
        if (hasWon == false)
        {
            //if (Input.GetKeyDown(KeyCode.R))
            //{
            //    RemoveRandomCardFromHand();
            //}

            Vector3 mousePos = Input.mousePosition;
            if (selectedCard != null)
            {
                mousePos.z = cardSelectedMouseWorldZ;
            }
            else
            {
                mousePos.z = mouseWorldZ;
            }
            Vector3 worldMousePos = Camera.main.ScreenToWorldPoint(mousePos);

            if (mouseWorldObject != null)
            {
                mouseWorldObject.transform.position = worldMousePos;
            }


            if (isPlayerTurn)
            {
                if (handDealt == false)
                {
                    if (cardObject != null && playerHandObject != null)
                    {
                        DealPlayerHand(currentMaxCardsInHand);
                        handDealt = true;
                    }

                    //Debug.Log("start player turn");
                }

                if (playerCharacterObject.isExecutingTurn == false)
                {
                    Ray        mouseRay = Camera.main.ScreenPointToRay(mousePos);
                    RaycastHit mouseHit;

                    if (selectedCard == null)
                    {
                        if (Input.GetMouseButtonDown(0))
                        {
                            if (Physics.Raycast(mouseRay, out mouseHit, 100f, cardMask))
                            {
                                if (mouseHit.transform.TryGetComponent(out selectedCard))
                                {
                                    selectedCard.isSelected = true;
                                    hasCardBeenSelected     = true;
                                }
                            }
                        }
                    }

                    if (Input.GetMouseButtonUp(0))
                    {
                        hasCardBeenSelected = false;
                    }

                    if (hasCardBeenSelected)
                    {
                        if (selectedCardPositionObject != null)
                        {
                            splineStartPoint.transform.position = selectedCard.GetStartPosition() + splineStartPositionOffset;

                            bezierPath.MovePoint(0, mouseWorldObject.transform.position);
                            bezierPath.MovePoint(bezierPath.NumPoints - 1, splineStartPoint.transform.position);

                            pathCreator.TriggerPathUpdate();

                            lineRenderer.enabled = true;

                            //selectedCard.transform.position = selectedCardPositionObject.transform.position;
                        }
                        //selectedCard.transform.position = mouseWorldObject.transform.position;
                    }
                    else
                    {
                        if (selectedCard != null)
                        {
                            lineRenderer.enabled = false;

                            if (selectedCard.cardDefinition.cardType == CARDTYPE.ATTACK)
                            {
                                if (selectedCard.cardDefinition.useOnGroup)
                                {
                                    UseCardEnemyGroup();
                                }
                                else
                                {
                                    if (Physics.Raycast(mouseRay, out mouseHit, 100f, characterMask))
                                    {
                                        UseCardSingleEnemy(mouseHit);
                                    }
                                    else
                                    {
                                        ResetCardPosition(selectedCard);
                                    }
                                }
                            }
                            else if (selectedCard.cardDefinition.cardType == CARDTYPE.ABILITY)
                            {
                                UseCardAbility();
                            }

                            selectedCard = null;
                        }
                    }

                    if (CheckHasWon())
                    {
                        ClearPlayerHand();
                        ReturnDiscardedToDeck();

                        hasWon = true;
                        if (OnHasWon != null)
                        {
                            OnHasWon.Invoke();
                        }
                    }
                }
            }
            else
            {
                ClearPlayerHand();

                bool allEnemyTurnsExecuted = true;

                if (playerCharacterObject.isDead)
                {
                    if (hasDied == false)
                    {
                        if (CheckHasDied())
                        {
                            if (OnPlayerDestroyed != null)
                            {
                                OnPlayerDestroyed.Invoke();
                            }
                        }
                    }
                }
                else
                {
                    //enemy turn
                    foreach (CharacterObject enemy in enemyCharacters)
                    {
                        if (enemy.isExecutingTurn == false && enemy.turnComplete == false && playerCharacterObject.currentHealth > 0)
                        {
                            enemy.ExecuteTurn(playerCharacterObject.transform, null);
                            allEnemyTurnsExecuted = false;
                        }
                        if (enemy.turnComplete == false)
                        {
                            allEnemyTurnsExecuted = false;
                            break;
                        }
                    }

                    if (allEnemyTurnsExecuted)
                    {
                        //Debug.Log("all enemy turns complete");

                        foreach (CharacterObject enemy in enemyCharacters)
                        {
                            enemy.ResetTurn();

                            if (OnTurnComplete != null)
                            {
                                OnTurnComplete.Invoke(enemy);
                            }
                        }

                        //ReturnDiscardedToDeck();

                        isPlayerTurn = true;
                        handDealt    = false;
                        ResetCardPoints();

                        if (OnEnemyTurnComplete != null)
                        {
                            OnEnemyTurnComplete.Invoke();
                        }

                        if (OnTurnComplete != null)
                        {
                            OnTurnComplete.Invoke(playerCharacterObject);
                        }
                    }
                }
            }
        }

        //else
        //{
        //    if (hasDied == false)
        //    {
        //        if (CheckHasDied())
        //        {
        //            if (OnHasDied != null)
        //            {
        //                OnHasDied.Invoke();
        //            }
        //        }
        //    }

        //}
    }
 public void OnObjectKilled()
 {
     ResetPosition();
     Blink();
     OnPlayerDestroyed?.Invoke();
 }